def test_pathInfo(self):
        """
        L{twcgi.CGIScript.render} sets the process environment I{PATH_INFO} from
        the request path.
        """
        class FakeReactor:
            """
            A fake reactor recording the environment passed to spawnProcess.
            """
            def spawnProcess(self, process, filename, args, env, wdir):
                """
                Store the C{env} L{dict} to an instance attribute.

                @param process: Ignored
                @param filename: Ignored
                @param args: Ignored
                @param env: The environment L{dict} which will be stored
                @param wdir: Ignored
                """
                self.process_env = env

        _reactor = FakeReactor()
        resource = twcgi.CGIScript(self.mktemp(), reactor=_reactor)
        request = DummyRequest(['a', 'b'])
        _render(resource, request)

        self.assertEqual(_reactor.process_env["PATH_INFO"],
                         "/a/b")

    def test_useReactorArgument(self):
        """
        L{twcgi.FilteredScript.runProcess} uses the reactor passed as an
        argument to the constructor.
        """
        class FakeReactor:
            """
            A fake reactor recording whether spawnProcess is called.
            """
            called = False
            def spawnProcess(self, *args, **kwargs):
                """
                Set the C{called} flag to C{True} if C{spawnProcess} is called.

                @param args: Positional arguments.
                @param kwargs: Keyword arguments.
                """
                self.called = True

        fakeReactor = FakeReactor()
        request = DummyRequest(['a', 'b'])
        resource = twcgi.FilteredScript("dummy-file", reactor=fakeReactor)
        _render(resource, request)

        self.assertTrue(fakeReactor.called)

    def test_renderWithHost(self):
        """
        L{NameVirtualHost.render} returns the result of rendering the resource
        which is the value in the instance's C{host} dictionary corresponding
        to the key indicated by the value of the I{Host} header in the request.
        """
        virtualHostResource = NameVirtualHost()
        virtualHostResource.addHost(b'example.org', Data(b"winner", ""))

        request = DummyRequest([b''])
        request.requestHeaders.addRawHeader(b'host', b'example.org')
        d = _render(virtualHostResource, request)
        def cbRendered(ignored, request):
            self.assertEqual(b''.join(request.written), b"winner")
        d.addCallback(cbRendered, request)

        # The port portion of the Host header should not be considered.
        requestWithPort = DummyRequest([b''])
        requestWithPort.requestHeaders.addRawHeader(b'host', b'example.org:8000')
        dWithPort = _render(virtualHostResource, requestWithPort)
        def cbRendered(ignored, requestWithPort):
            self.assertEqual(b''.join(requestWithPort.written), b"winner")
        dWithPort.addCallback(cbRendered, requestWithPort)

        return gatherResults([d, dWithPort])

    def test_render(self):
        """
        L{UserDirectory} renders a list of links to available user content
        in response to a I{GET} request.
        """
        public_html = filepath.FilePath(self.alice[-2]).child('public_html')
        public_html.makedirs()
        web = filepath.FilePath(self.bob[-2])
        web.makedirs()
        # This really only works if it's a unix socket, but the implementation
        # doesn't currently check for that.  It probably should someday, and
        # then skip users with non-sockets.
        web.child('.twistd-web-pb').setContent("")

        request = DummyRequest([''])
        result = _render(self.directory, request)
        def cbRendered(ignored):
            document = parseString(''.join(request.written))

            # Each user should have an li with a link to their page.
            [alice, bob] = document.getElementsByTagName('li')
            self.assertEqual(alice.firstChild.tagName, 'a')
            self.assertEqual(alice.firstChild.getAttribute('href'), 'alice/')
            self.assertEqual(alice.firstChild.firstChild.data, 'Alice (file)')
            self.assertEqual(bob.firstChild.tagName, 'a')
            self.assertEqual(bob.firstChild.getAttribute('href'), 'bob.twistd/')
            self.assertEqual(bob.firstChild.firstChild.data, 'Bob (twistd)')

        result.addCallback(cbRendered)
        return result

    def test_unknown_request_id(self):
        self.request.addArg('request_id', 'xxx')

        def on_rendered(_):
            self.assertEqual(self.request.responseCode, 503)
            self.assertEqual(['Request not found'], self.request.written)

        return _render(self.resource, self.request).addCallback(on_rendered)

    def test_success(self):
        self.request.addArg('request_id', 'xxx')
        self.resource.factory.requests['xxx'] = DecoupledRequest(
            self.resource.factory, 'xxx', DummyRequest(['']))

        def on_rendered(_):
            self.assertEqual(['ok'], self.request.written)

        return _render(self.resource, self.request).addCallback(on_rendered)

 def test00_render(self):
     tree = CardstoriesTree(self.service)
     request = DummyRequest(['agpl'])
     child = resource.getChildForRequest(tree, request)
     self.assertTrue(isinstance(child, AGPLResource))
     d = _render(child, request)
     def finish(result):
         self.assertEquals('PK', request.written[0][:2])
     d.addCallback(finish)
     return d

    def test_success(self):
        def on_rendered(_):
            self.assertEqual(['backend reply'], self.request.written)

        d = _render(self.resource, self.request).addCallback(on_rendered)

        callback_request = DummyRequest([''])
        callback_request.content = StringIO('backend reply')

        self.resource.factory.requests.values()[0].notify(callback_request)
        return d

 def test_notFoundRender(self):
     """
     If the source file a L{PythonScript} is initialized with doesn't exist,
     L{PythonScript.render} sets the HTTP response code to I{NOT FOUND}.
     """
     resource = PythonScript(self.mktemp(), None)
     request = DummyRequest([''])
     d = _render(resource, request)
     def cbRendered(ignored):
         self.assertEqual(request.responseCode, NOT_FOUND)
     d.addCallback(cbRendered)
     return d

 def test_render(self):
     """
     L{twcgi.CGIDirectory.render} sets the HTTP response code to I{NOT
     FOUND}.
     """
     resource = twcgi.CGIDirectory(self.mktemp())
     request = DummyRequest([''])
     d = _render(resource, request)
     def cbRendered(ignored):
         self.assertEqual(request.responseCode, NOT_FOUND)
     d.addCallback(cbRendered)
     return d

 def _404Test(self, name):
     """
     Verify that requesting the C{name} child of C{self.directory} results
     in a 404 response.
     """
     request = DummyRequest([name])
     result = self.directory.getChild(name, request)
     d = _render(result, request)
     def cbRendered(ignored):
         self.assertEqual(request.responseCode, 404)
     d.addCallback(cbRendered)
     return d

 def test_renderWithoutHostNoDefault(self):
     """
     L{NameVirtualHost.render} returns a response with a status of I{NOT
     FOUND} if the instance's C{default} is C{None} and there is no I{Host}
     header in the request.
     """
     virtualHostResource = NameVirtualHost()
     request = DummyRequest([''])
     d = _render(virtualHostResource, request)
     def cbRendered(ignored):
         self.assertEqual(request.responseCode, NOT_FOUND)
     d.addCallback(cbRendered)
     return d

 def test_renderWithUnknownHostNoDefault(self):
     """
     L{NameVirtualHost.render} returns a response with a status of I{NOT
     FOUND} if the instance's C{default} is C{None} and there is no host
     matching the value of the I{Host} header in the request.
     """
     virtualHostResource = NameVirtualHost()
     request = DummyRequest([''])
     request.requestHeaders.addRawHeader(b'host', b'example.com')
     d = _render(virtualHostResource, request)
     def cbRendered(ignored):
         self.assertEqual(request.responseCode, NOT_FOUND)
     d.addCallback(cbRendered)
     return d

 def test_childrenNotFound(self):
     """
     Any child resource of L{static.DirectoryLister} renders an HTTP
     I{NOT FOUND} response code.
     """
     path = FilePath(self.mktemp())
     path.makedirs()
     lister = static.DirectoryLister(path.path)
     request = self._request('')
     child = resource.getChildForRequest(lister, request)
     result = _render(child, request)
     def cbRendered(ignored):
         self.assertEquals(request.responseCode, http.NOT_FOUND)
     result.addCallback(cbRendered)
     return result

 def test_renderWithUnknownHost(self):
     """
     L{NameVirtualHost.render} returns the result of rendering the
     instance's C{default} if it is not C{None} and there is no host
     matching the value of the I{Host} header in the request.
     """
     virtualHostResource = NameVirtualHost()
     virtualHostResource.default = Data(b"correct data", "")
     request = DummyRequest([b''])
     request.requestHeaders.addRawHeader(b'host', b'example.com')
     d = _render(virtualHostResource, request)
     def cbRendered(ignored):
         self.assertEqual(b''.join(request.written), b"correct data")
     d.addCallback(cbRendered)
     return d

    def test00_render_static(self):
        file = "file"
        fd = open(file, "w")
        fd.write('CONTENT')
        fd.close()

        tree = CardstoriesTree(self.service)
        request = DummyRequest(['static', 'file'])
        child = resource.getChildForRequest(tree, request)

        self.assertTrue(isinstance(child, filepath.FilePath))
        d = _render(child, request)
        def finish(result):
            self.assertEquals(['CONTENT'], request.written)
        d.addCallback(finish)
        return d

 def test_renderException(self):
     """
     L{ResourceScriptDirectory.getChild} returns a resource which renders a
     response with the HTTP 200 status code and the content of the rpy's
     C{request} global.
     """
     tmp = FilePath(self.mktemp())
     tmp.makedirs()
     child = tmp.child("test.epy")
     child.setContent(b'raise Exception("nooo")')
     resource = PythonScript(child._asBytesPath(), None)
     request = DummyRequest([b''])
     d = _render(resource, request)
     def cbRendered(ignored):
         self.assertIn(b"nooo", b"".join(request.written))
     d.addCallback(cbRendered)
     return d

 def test_notFoundChild(self):
     """
     L{twcgi.CGIDirectory.getChild} returns a resource which renders an
     response with the HTTP I{NOT FOUND} status code if the indicated child
     does not exist as an entry in the directory used to initialized the
     L{twcgi.CGIDirectory}.
     """
     path = self.mktemp()
     os.makedirs(path)
     resource = twcgi.CGIDirectory(path)
     request = DummyRequest(['foo'])
     child = resource.getChild("foo", request)
     d = _render(child, request)
     def cbRendered(ignored):
         self.assertEqual(request.responseCode, NOT_FOUND)
     d.addCallback(cbRendered)
     return d

def renderResource(resource, path, params=None, method=b"GET", body=b"", isSecure=False,
                   headers=None, sign=False, signKey=None, signSecret=None):

    params = {} if params is None else params
    headers = {} if params is None else headers

    def _cb(result, request):
        return request

    if sign:
        params = makeSignedArguments(params, signKey, signSecret, body)

    req = request(path, args=params, method=method, isSecure=isSecure,
                  headers=headers, body=body)

    d = _render(resource, req)
    d.addCallback(_cb, req)
    return d

    def test_connectionLost(self):
        """
        If there is an error issuing the request to the remote publisher, an
        error response is returned.
        """
        # Using pb.Root as a publisher will cause request calls to fail with an
        # error every time.  Just what we want to test.
        self.f1 = serverFactory = PBServerFactory(pb.Root())
        self.port1 = serverPort = reactor.listenTCP(0, serverFactory)

        self.sub = subscription = distrib.ResourceSubscription(
            "127.0.0.1", serverPort.getHost().port)
        request = DummyRequest([''])
        d = _render(subscription, request)
        def cbRendered(ignored):
            self.assertEqual(request.responseCode, 500)
            # This is the error we caused the request to fail with.  It should
            # have been logged.
            errors = self.flushLoggedErrors(pb.NoSuchMethod)
            self.assertEqual(len(errors), 1)
            # The error page is rendered as HTML.
            expected = [
                '',
                '<html>',
                '  <head><title>500 - Server Connection Lost</title></head>',
                '  <body>',
                '    <h1>Server Connection Lost</h1>',
                '    <p>Connection to distributed server lost:'
                    '<pre>'
                    '[Failure instance: Traceback from remote host -- '
                    'Traceback unavailable',
                'twisted.spread.flavors.NoSuchMethod: '
                    'No such method: remote_request',
                ']</pre></p>',
                '  </body>',
                '</html>',
                ''
                ]
            self.assertEqual(['\n'.join(expected)], request.written)

        d.addCallback(cbRendered)
        return d