def test_putNamedChild_django_static_override(self):
     "check that overridden resources work"
     with mock.patch('hendrix.facilities.resources.WSGIResource') as wsgi:
         static_dir = os.path.join(os.path.dirname(__file__),'testproject','static')
         
         # Django finders import in order of INSTALLED_APPS so overrides must happen first
         overridden_media = DjangoStaticResource(static_dir+'/override/css','/static/base/css') # Same rel_url -> overrides
         self.hr.putNamedChild(overridden_media)
         base_media = DjangoStaticResource(static_dir+'/base/css','/static/base/css')
         self.hr.putNamedChild(base_media)
         
         # main.css file should be the same as it is not overridden
         request = DummyRequest(['static', 'base', 'css','main.css'])
         actual_res = getChildForRequest(self.hr, request)
         with actual_res.open() as f:
             actual_content = f.read() 
             
         with open(static_dir+'/base/css/main.css') as f:
             expected_content = f.read()
         self.assertEqual(expected_content,actual_content)
         
         # form.css should be the same as the overridden folder 
         request = DummyRequest(['static', 'base', 'css','form.css'])
         actual_res = getChildForRequest(self.hr, request)
         with actual_res.open() as f:
             actual_content = f.read()
         with open(static_dir+'/override/css/form.css') as f:
             expected_content = f.read()
         self.assertEqual(expected_content,actual_content)

 def testDeferredResource(self):
     r = resource.Resource()
     r.isLeaf = 1
     s = SDResource(r)
     d = DummyRequest(["foo", "bar", "baz"])
     resource.getChildForRequest(s, d)
     self.assertEqual(d.postpath, ["bar", "baz"])

 def test_putNamedChild_duplicate(self):
     "check that duplicate resources work"
     with mock.patch('hendrix.facilities.resources.WSGIResource') as wsgi:
         request = DummyRequest(['path', 'to', 'child'])
         actual_res = getChildForRequest(self.hr, request)
         self.assertEqual(self.res, actual_res) # Before duplicate
         
         duplicate = NamedResource(self.res.namespace)
         self.hr.putNamedChild(duplicate)
         request = DummyRequest(['path', 'to', 'child'])
         actual_duplicate_res = getChildForRequest(self.hr, request)
         self.assertEqual(duplicate, actual_duplicate_res) # After duplicate

 def test_get_blobs_enabled(self):
     blobs_resource = BlobsResource("filesystem", '/tmp')
     streaming_resource = StreamingResource("filesystem", '/tmp')
     resource = PublicResource(
         blobs_resource=blobs_resource,
         streaming_resource=streaming_resource,
         sync_pool=_pool)
     request = DummyRequest(['blobs'])
     child = getChildForRequest(resource, request)
     self.assertIsInstance(child, BlobsResource)
     request = DummyRequest(['stream'])
     child = getChildForRequest(resource, request)
     self.assertIsInstance(child, StreamingResource)

 def test_get_root(self):
     blobs_resource = None  # doesn't matter
     resource = PublicResource(
         blobs_resource=blobs_resource, sync_pool=_pool)
     request = DummyRequest([''])
     child = getChildForRequest(resource, request)
     self.assertIsInstance(child, ServerInfo)

    def test_unexpectedDecodeError(self):
        """
        Any unexpected exception raised by the credential factory's C{decode}
        method results in a 500 response code and causes the exception to be
        logged.
        """
        class UnexpectedException(Exception):
            pass

        class BadFactory(object):
            scheme = 'bad'

            def getChallenge(self, client):
                return {}

            def decode(self, response, request):
                raise UnexpectedException()

        self.credentialFactories.append(BadFactory())
        request = self.makeRequest([self.childName])
        request.headers['authorization'] = 'Bad abc'
        child = getChildForRequest(self.wrapper, request)
        request.render(child)
        self.assertEqual(request.responseCode, 500)
        self.assertEqual(len(self.flushLoggedErrors(UnexpectedException)), 1)

    def test_locateChildSpinneretResource(self):
        """
        If ``locateChild`` returns something adaptable to `ISpinneretResource`
        it is adapted to an `IResource`.
        """
        @implementer(ISpinneretResource)
        class _ResultingResource(object):
            def render_GET(zelf, request):
                request.setResponseCode(http.OK)
                return b'hello world'

        @implementer(ISpinneretResource)
        class _TestResource(object):
            def locateChild(zelf, request, segments):
                return _ResultingResource(), []

        resource = SpinneretResource(_TestResource())
        request = InMemoryRequest([''])
        request.method = b'GET'
        result = getChildForRequest(resource, request)
        request.render(result)
        self.assertThat(
            b''.join(request.written),
            Equals(b'hello world'))
        self.assertThat(
            http.OK,
            Equals(request.responseCode))
        self.assertThat(
            request.postpath,
            Equals([]))

    def test_locateChildRenderable(self):
        """
        If ``locateChild`` returns something adaptable to `IRenderable` it is
        rendered.
        """
        class _TestElement(Element):
            loader = TagLoader(tags.span(u'Hello ', tags.em(u'World')))

        @implementer(ISpinneretResource)
        class _TestResource(object):
            def locateChild(zelf, request, segments):
                return _TestElement(), []

        resource = SpinneretResource(_TestResource())
        request = InMemoryRequest([''])
        result = getChildForRequest(resource, request)
        request.render(result)
        self.assertThat(
            b''.join(request.written),
            Equals(b'<!DOCTYPE html>\n<span>Hello <em>World</em></span>'))
        self.assertThat(
            http.OK,
            Equals(request.responseCode))
        self.assertThat(
            request.postpath,
            Equals([]))

    def test_getChallengeCalledWithRequest(self):
        """
        When L{HTTPAuthSessionWrapper} finds an L{ICredentialFactory} to issue
        a challenge, it calls the C{getChallenge} method with the request as an
        argument.
        """
        class DumbCredentialFactory(object):
            implements(ICredentialFactory)
            scheme = 'dumb'

            def __init__(self):
                self.requests = []

            def getChallenge(self, request):
                self.requests.append(request)
                return {}

        factory = DumbCredentialFactory()
        self.credentialFactories.append(factory)
        request = self.makeRequest([self.childName])
        child = getChildForRequest(self.wrapper, request)
        d = request.notifyFinish()
        def cbFinished(ignored):
            self.assertEqual(factory.requests, [request])
        d.addCallback(cbFinished)
        request.render(child)
        return d

    def test_locateChildResource(self):
        """
        If ``locateChild`` returns something adaptable to `IResource` it is
        returned.
        """
        class _ResultingResource(Resource):
            isLeaf = True
            def render(zelf, request):
                request.setResponseCode(http.OK)
                return b'hello world'

        class _TestResource(SpinneretResource):
            def locateChild(zelf, request, segments):
                return _ResultingResource(), segments

        resource = _TestResource()
        request = InMemoryRequest([''])
        result = getChildForRequest(resource, request)
        request.render(result)
        self.assertThat(
            b''.join(request.written),
            Equals(b'hello world'))
        self.assertThat(
            http.OK,
            Equals(request.responseCode))

        def process(r):
            if IResource.providedBy(r):
                return request.render(getChildForRequest(r, request))

            if IRenderable.providedBy(r):
                return flattenString(request, r).addCallback(process)

            return r

 def test_get_sync(self):
     blobs_resource = None  # doesn't matter
     resource = PublicResource(
         blobs_resource=blobs_resource, sync_pool=_pool)
     request = DummyRequest(['user-db', 'sync-from', 'source-id'])
     child = getChildForRequest(resource, request)
     self.assertIsInstance(child, WSGIResource)
     self.assertIsInstance(child._application, GzipMiddleware)

    def test_info(self):
        '''The Info resource must be accessible as the "info" child of the
        TxDarn resource.

        '''
        self.request.postpath = [b'info']
        resrc = getChildForRequest(self.txdarn, self.request)
        self.assertIs(resrc, self.txdarn.info)

 def render_GET(self, request):
     try:
         index = request.args["code"][0]
         self.main.removeMessage(index)
         request.render(getChildForRequest(Index(self.main), request))
         return NOT_DONE_YET
     except:
         return "Error"

 def getChild(self, child, request ):
     if not self.static:
         return self.prepareWSGI(child, request)
     else:
         resource = getChildForRequest(self.static, request)
         if not hasattr(resource, "isdir") or resource.isdir() or not resource.exists():
             return self.prepareWSGI(child, request)
         else:
             return resource

 def _authorizedBasicLogin(self, request):
     """
     Add an I{basic authorization} header to the given request and then
     dispatch it, starting from C{self.wrapper} and returning the resulting
     L{IResource}.
     """
     authorization = b64encode(self.username + ':' + self.password)
     request.headers['authorization'] = 'Basic ' + authorization
     return getChildForRequest(self.wrapper, request)

    def test_locateChildSetPostpath(self):
        """
        The second elements in ``locateChild`` return value is the new request
        postpath.
        """
        class _TestResource(SpinneretResource):
            def locateChild(zelf, request, segments):
                return None, [b'quux']

        resource = _TestResource()
        request = InMemoryRequest([b'foo', b'bar'])
        self.assertThat(
            request.postpath,
            Equals([b'foo', b'bar']))
        getChildForRequest(resource, request)
        self.assertThat(
            request.postpath,
            Equals([b'quux']))

    def test_greeting_trailing_slash(self):
        '''The Greeting resource must be accessible as the direct child of the
        TxDarn resource (i.e., with a trailing slash).

        '''
        # a trailing slash -- empty string in postpath
        self.request.postpath = [b'']
        resrc = getChildForRequest(self.txdarn, self.request)
        self.assertIs(resrc, self.txdarn.greeting)

 def test_exhaustedPostPath(self):
     """
     L{getChildForRequest} returns whatever resource has been reached by the
     time the request's C{postpath} is empty.
     """
     request = DummyRequest([])
     resource = Resource()
     result = getChildForRequest(resource, request)
     self.assertIdentical(resource, result)

 def test_get_blobs_disabled(self):
     blobs_resource = None
     resource = PublicResource(
         blobs_resource=blobs_resource, sync_pool=_pool)
     request = DummyRequest(['blobs'])
     child = getChildForRequest(resource, request)
     # if blobs is disabled, the request should be routed to sync
     self.assertIsInstance(child, WSGIResource)
     self.assertIsInstance(child._application, GzipMiddleware)