Python _util._render函数代码示例

    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