Ticket #3207: test_client.py.patch

web2/test/test_client.py

@@ -5 +5 @@
 Tests for HTTP client.
 """
 
-from twisted.internet import protocol, defer
+from twisted.internet import protocol, defer, reactor
 
 from twisted.web2.client import http
 from twisted.web2 import http_headers
@@ -35 +35 @@
 
 
 class ClientTests(HTTPTests):
-    def connect(self, logFile=None, maxPipeline=4,
+    def connect(self, mgr = None, logFile=None, maxPipeline=4,
                 inputTimeOut=60000, betweenRequestsTimeOut=600000):
         cxn = TestConnection()
 
-        cxn.client = http.HTTPClientProtocol()
+        cxn.client = http.HTTPClientProtocol(mgr)
         cxn.client.inputTimeOut = inputTimeOut
         cxn.server = TestServer()
 
@@ -492 +492 @@
         d.addCallback(cb)
         return d
 
+class TestHTTPClientManager(object):
+    """
+    An HTTPClientManager for testing purposes. It calls a deferred
+    whenever the client becomes Idle, Gone, or Pipelined.
+    """
+
+    def __init__(self):
+        self.df = defer.Deferred()
+
+    def clientBusy(self, proto):
+        pass
+
+    def clientIdle(self, proto):
+        df = self.df
+        self.df = defer.Deferred()
+        df.callback('idle')
+
+    def clientPipelining(self, proto):
+        df = self.df
+        self.df = defer.Deferred()
+        df.callback('pipeline')
+
+    def clientGone(self, proto):
+        df = self.df
+        self.df = defer.Deferred()
+        df.callback('gone')
+
+class TestHTTPClientPipelining(ClientTests):
+    """
+    Test that the http client works with pipelined requests.
+    """
+    
+    timeout = 2
+    
+    def test_pipelining(self):
+        """
+        Submitting multiple requests using the manager.
+        """
+        requests = 5
+        mgr = TestHTTPClientManager()
+        cxn = self.connect(mgr = mgr, inputTimeOut=None)
+        req = http.ClientRequest('GET', '/', None, None)
+
+        didIt = [0]
+
+        def sendData(resp, data):
+            reactor.callLater(0, self.writeToClient, cxn, data)
+            return resp
+
+        def sendNextResponse(resp, data):
+            reactor.callLater(0, self.writeLines, cxn, data)
+            return resp
+
+        def submitRequest(_):
+            didIt[0] += 1
+
+            if didIt[0] == requests - 1:
+                keepAlive='close'
+            else:
+                keepAlive='Keep-Alive'
+
+            cxn.server.data = ''
+            df = mgr.df
+
+            d = cxn.client.submitRequest(req, closeAfter=(didIt[0] == requests))
+            d.addCallback(sendData, 'foobar' + str(didIt[0]))
+            
+            if didIt[0] < requests:
+                d.addCallback(sendNextResponse, ('HTTP/1.1 200 OK',
+                                      'Connection: '+ keepAlive,
+                                      'Content-Length: 7',
+                                      '\r\n'))
+                d.addCallback(self.checkResponse, 200, [], 7, 'foobar' + str(didIt[0]))
+                df.addCallback(submitRequest)
+            
+            if didIt[0] == 1:
+                self.writeLines(cxn, ('HTTP/1.1 200 OK',
+                                      'Connection: '+ keepAlive,
+                                      'Content-Length: 7',
+                                      '\r\n'))
+
+            d = defer.DeferredList([d, df], fireOnOneErrback=True)
+            if didIt[0] == requests:
+                d.addCallback(lambda _: self.assertDone(cxn))
+            return d
+
+        d = submitRequest(None)
+
+        return d
+
+    def test_firstRequestPipeline(self):
+        """
+        Verify that the client manager gets a call before the first
+        request completes.
+        """
+        mgr = TestHTTPClientManager()
+        cxn = self.connect(mgr = mgr, inputTimeOut=None)
+        req = http.ClientRequest('GET', '/', None, None)
+
+        def gotData(data):
+            self.assertEquals(data, '1234567890')
+
+        def sendResp(type):
+            self.assertEquals(type, 'pipeline')
+
+        def gotResp(resp):
+            self.assertEquals(resp.code, 200)
+            self.assertHeaders(resp, [])
+            self.assertEquals(resp.stream.length, 10)
+
+            self.writeToClient(cxn, '1234567890')
+
+            return defer.maybeDeferred(resp.stream.read).addCallback(gotData)
+
+        df = mgr.df.addCallback(sendResp)
+        d = cxn.client.submitRequest(req, closeAfter = False).addCallback(gotResp)
+
+        self.assertReceived(cxn, 'GET / HTTP/1.1',
+                            ['Connection: Keep-Alive'])
+
+        self.writeLines(cxn, ('HTTP/1.1 200 OK',
+                              'Content-Length: 10',
+                              '\r\n'))
+
+        return df
+
+    def test_pipelineClosed(self):
+        """
+        Submitting multiple requests but the server closes the connection
+        while there are pipelined requests.
+        """
+        requests = 5
+        stopAfter = 2
+        mgr = TestHTTPClientManager()
+        cxn = self.connect(mgr = mgr, inputTimeOut=None)
+        req = http.ClientRequest('GET', '/', None, None)
+
+        didIt = [0]
+
+        def sendData(resp, data):
+            reactor.callLater(0, self.writeToClient, cxn, data)
+            return resp
+
+        def sendNextResponse(resp, data):
+            reactor.callLater(0, self.writeLines, cxn, data)
+            return resp
+
+        def submitRequest(_):
+            didIt[0] += 1
+
+            if didIt[0] == requests - 1 or didIt[0] == stopAfter:
+                keepAlive='close'
+            else:
+                keepAlive='Keep-Alive'
+
+            cxn.server.data = ''
+            df = mgr.df
+
+            d = cxn.client.submitRequest(req, closeAfter=(didIt[0] == requests))
+            d.addCallback(sendData, 'foobar' + str(didIt[0]))
+            
+            if didIt[0] < requests:
+                if didIt[0] <= stopAfter:
+                    d.addCallback(sendNextResponse, ('HTTP/1.1 200 OK',
+                                          'Connection: '+ keepAlive,
+                                          'Content-Length: 7',
+                                          '\r\n'))
+                    d.addCallback(self.checkResponse, 200, [], 7, 'foobar' + str(didIt[0]))
+                else:
+                    self.assertFailure(d, getattr(http, 'PipelineError', http.ProtocolError))
+                d = df.addCallback(submitRequest)
+            else:
+                self.assertFailure(d, getattr(http, 'PipelineError', http.ProtocolError))
+
+            if didIt[0] == 1:
+                self.writeLines(cxn, ('HTTP/1.1 200 OK',
+                                      'Connection: '+ keepAlive,
+                                      'Content-Length: 7',
+                                      '\r\n'))
+
+            d = defer.DeferredList([d, df], fireOnOneErrback=True)
+            if didIt[0] == requests:
+                d.addCallback(lambda _: self.assertDone(cxn))
+            return d
+
+        d = submitRequest(None)
+
+        return d
+
+    def test_pipelineStreamClosed(self):
+        """
+        Submitting multiple requests but the client closes the stream
+        of a request while there are other requests pipelined.
+        """
+        requests = 5
+        closeAfter = 3
+        mgr = TestHTTPClientManager()
+        cxn = self.connect(mgr = mgr, inputTimeOut=None)
+        req = http.ClientRequest('GET', '/', None, None)
+
+        didIt = [0]
+
+        def sendData(resp, data):
+            reactor.callLater(0, self.writeToClient, cxn, data)
+            return resp
+
+        def sendNextResponse(resp, data):
+            reactor.callLater(0, self.writeLines, cxn, data)
+            return resp
+
+        def closeStream(resp, code, headers, length, data):
+            def gotData(gotdata):
+                self.assertEquals(gotdata, data)
+            self.assertEquals(resp.code, code)
+            self.assertHeaders(resp, headers)
+            self.assertEquals(resp.stream.length, length)
+            resp.stream.close()
+
+        def submitRequest(_):
+            didIt[0] += 1
+
+            if didIt[0] == requests - 1:
+                keepAlive='close'
+            else:
+                keepAlive='Keep-Alive'
+
+            cxn.server.data = ''
+            df = mgr.df
+
+            d = cxn.client.submitRequest(req, closeAfter=(didIt[0] == requests))
+            d.addCallback(sendData, 'foobar' + str(didIt[0]))
+            
+            if didIt[0] < requests:
+                if didIt[0] <= closeAfter:
+                    d.addCallback(sendNextResponse, ('HTTP/1.1 200 OK',
+                                          'Connection: '+ keepAlive,
+                                          'Content-Length: 7',
+                                          '\r\n'))
+                    if didIt[0] == closeAfter:
+                        d.addCallback(closeStream, 200, [], 7, 'foobar' + str(didIt[0]))
+                    else:
+                        d.addCallback(self.checkResponse, 200, [], 7, 'foobar' + str(didIt[0]))
+                else:
+                    self.assertFailure(d, getattr(http, 'PipelineError', http.ProtocolError))
+                d = df.addCallback(submitRequest)
+            else:
+                self.assertFailure(d, getattr(http, 'PipelineError', http.ProtocolError))
+
+            if didIt[0] == 1:
+                self.writeLines(cxn, ('HTTP/1.1 200 OK',
+                                      'Connection: '+ keepAlive,
+                                      'Content-Length: 7',
+                                      '\r\n'))
+
+            d = defer.DeferredList([d, df], fireOnOneErrback=True)
+            if didIt[0] == requests:
+                d.addCallback(lambda _: self.assertDone(cxn))
+            return d
+
+        d = submitRequest(None)
+
+        return d