Update overly complicated proxy integration test cases with simple ones

Author: fredthomsen

test/server.py

@@ -81,53 +81,6 @@ def _wrap_socket(self, sock):
     def run(self):
         self.server = self._start_server()
 
-class SocketProxyThread(threading.Thread):
-    """
-    :param ready_event: Event which gets set when the socket handler is
-        ready to receive requests.
-    """
-    def __init__(self,
-                 socket_handler,
-                 proxy_host='localhost',
-                 host='localhost',
-                 port=80,
-                 secure=False):
-        threading.Thread.__init__(self)
-
-        self.socket_handler = socket_handler
-        self.host = host
-        self.port = port
-        self.proxy_host = proxy_host
-        self.proxy_port = None
-        self.secure = secure
-        self.daemon = True
-
-        assert not self.secure, "HTTPS Proxies not supported"
-
-    def _start_proxy(self):
-        tx_sock = socket.socket(socket.AF_INET6)
-        rx_sock = socket.socket(socket.AF_INET6)
-
-        if sys.platform != 'win32':
-            for sock in [tx_sock, rx_sock]:
-                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-
-        rx_sock.bind((self.proxy_host, 0))
-        self.proxy_port = rx_sock.getsockname()[1]
-
-        # Once listen() returns, the server socket is ready
-        rx_sock.listen(1)
-        tx_sock.connect((self.host, self.port))
-
-        self.socket_handler(tx_sock, rx_sock)
-        sock.close()
-
-    def _wrap_socket(self, sock):
-        raise NotImplementedError()
-
-    def run(self):
-        self.proxy_server = self._start_proxy()
-
 
 class SocketLevelTest(object):
     """
@@ -137,15 +90,9 @@ class SocketLevelTest(object):
     def set_up(self, secure=True, proxy=False):
         self.host = None
         self.port = None
-
-        self.proxy = proxy
-        self.proxy_host = None
-        self.proxy_port = None
-
         self.secure = secure if not proxy else False
-
+        self.proxy = proxy
         self.server_thread = None
-        self.proxy_thread = None
 
     def _start_server(self, socket_handler):
         """
@@ -160,38 +107,23 @@ def _start_server(self, socket_handler):
         )
         self.server_thread.start()
         ready_event.wait()
+
         self.host = self.server_thread.host
         self.port = self.server_thread.port
         self.secure = self.server_thread.secure
 
-        if self.proxy:
-            self._start_proxy()
-
-            self.proxy_host = self.proxy_thread.proxy_host
-            self.proxy_port = self.proxy_thread.proxy_port
-            self.secure = self.proxy_thread.secure
-
-    def _start_proxy(self):
-        """
-        Starts a background thread that runs the given socket handler.
-        """
-        def _proxy_socket_handler(tx_sock, rx_sock):
-            rx_sock_add = rx_sock.accept()[0]
-            tx_sock.send(rx_sock_add.recv(65535))
-            rx_sock_add.close()
-
-        self.proxy_thread = SocketProxyThread(
-            socket_handler=_proxy_socket_handler,
-            host=self.host,
-            port=self.port
-        )
-        self.proxy_thread.start()
-
     def get_connection(self):
         if self.h2:
-            return HTTP20Connection(self.host, self.port, self.secure, proxy_host=self.proxy_host, proxy_port=self.proxy_port)
+            if not self.proxy:
+                return HTTP20Connection(self.host, self.port, self.secure)
+            else:
+                return HTTP20Connection('http2bin.org', secure=self.secure, proxy_host=self.host, proxy_port=self.port)
         else:
-            return HTTP11Connection(self.host, self.port, self.secure, proxy_host=self.proxy_host, proxy_port=self.proxy_port)
+            if not self.proxy:
+                return HTTP11Connection(self.host, self.port, self.secure)
+            else:
+                return HTTP11Connection('httpbin.org', secure=self.secure, proxy_host=self.host, proxy_port=self.port)
+
 
     def get_encoder(self):
         """
@@ -206,6 +138,3 @@ def tear_down(self):
         Tears down the testing thread.
         """
         self.server_thread.join(0.1)
-
-        if self.proxy:
-            self.proxy_thread.join(0.1)

test/test_integration.py

@@ -506,6 +506,54 @@ def socket_handler(listener):
 
         self.tear_down()
 
+    def test_proxy_connection(self):
+        self.set_up(proxy=True)
+
+        data = []
+        send_event = threading.Event()
+
+        def socket_handler(listener):
+            sock = listener.accept()[0]
+
+            receive_preamble(sock)
+
+            data.append(sock.recv(65535))
+            send_event.wait()
+
+            h = HeadersFrame(1)
+            h.data = self.get_encoder().encode(
+                {':status': 200,
+                'Content-Type': 'not/real',
+                'Content-Length': 14,
+                'Server': 'socket-level-server'}
+            )
+            h.flags.add('END_HEADERS')
+            sock.send(h.serialize())
+
+            d = DataFrame(1)
+            d.data = b'thisisaproxy'
+            d.flags.add('END_STREAM')
+            sock.send(d.serialize())
+
+            sock.close()
+
+        self._start_server(socket_handler)
+        c = self.get_connection()
+        c.request('GET', '/')
+        send_event.set()
+        r = c.get_response()
+
+        assert r.status == 200
+        assert len(r.headers) == 3
+        assert r.headers[b'server'] == [b'socket-level-server']
+        assert r.headers[b'content-length'] == [b'12']
+        assert r.headers[b'content-type'] == [b'not/real']
+
+        assert r.read() == b'thisisaproxy'
+
+        self.tear_down()
+
+
     def test_resetting_stream_with_frames_in_flight(self):
         """
         Hyper emits only one RST_STREAM frame, despite the other frames in

test/test_integration_http11.py

@@ -69,8 +69,8 @@ def socket_handler(listener):
 
         assert c._sock is None
 
-    def test_proxy(self):
-        self.set_up(secure=False, proxy=True)
+    def test_closing_response(self):
+        self.set_up()
 
         send_event = threading.Event()
 
@@ -86,14 +86,23 @@ def socket_handler(listener):
 
             # We need to send back a response.
             resp = (
-                b'HTTP/1.1 201 No Content\r\n'
+                b'HTTP/1.1 200 OK\r\n'
                 b'Server: socket-level-server\r\n'
-                b'Content-Length: 0\r\n'
                 b'Connection: close\r\n'
                 b'\r\n'
             )
             sock.send(resp)
 
+            chunks = [
+                b'hello',
+                b'there',
+                b'sir',
+                b'finalfantasy',
+            ]
+
+            for chunk in chunks:
+                sock.send(chunk)
+
             sock.close()
 
         self._start_server(socket_handler)
@@ -102,20 +111,16 @@ def socket_handler(listener):
         send_event.set()
         r = c.get_response()
 
-        assert r.status == 201
-        assert r.reason == b'No Content'
-        assert len(r.headers) == 3
+        assert r.status == 200
+        assert r.reason == b'OK'
+        assert len(r.headers) == 2
         assert r.headers[b'server'] == [b'socket-level-server']
-        assert r.headers[b'content-length'] == [b'0']
         assert r.headers[b'connection'] == [b'close']
 
-        assert r.read() == b''
+        assert r.read() == b'hellotheresirfinalfantasy'
 
-        assert c._sock is None
-       
-
-    def test_closing_response(self):
-        self.set_up()
+    def test_proxy_request_response(self):
+        self.set_up(proxy=True)
 
         send_event = threading.Event()
 
@@ -131,23 +136,14 @@ def socket_handler(listener):
 
             # We need to send back a response.
             resp = (
-                b'HTTP/1.1 200 OK\r\n'
+                b'HTTP/1.1 201 No Content\r\n'
                 b'Server: socket-level-server\r\n'
+                b'Content-Length: 0\r\n'
                 b'Connection: close\r\n'
                 b'\r\n'
             )
             sock.send(resp)
 
-            chunks = [
-                b'hello',
-                b'there',
-                b'sir',
-                b'finalfantasy',
-            ]
-
-            for chunk in chunks:
-                sock.send(chunk)
-
             sock.close()
 
         self._start_server(socket_handler)
@@ -156,13 +152,17 @@ def socket_handler(listener):
         send_event.set()
         r = c.get_response()
 
-        assert r.status == 200
-        assert r.reason == b'OK'
-        assert len(r.headers) == 2
+        assert r.status == 201
+        assert r.reason == b'No Content'
+        assert len(r.headers) == 3
         assert r.headers[b'server'] == [b'socket-level-server']
+        assert r.headers[b'content-length'] == [b'0']
         assert r.headers[b'connection'] == [b'close']
 
-        assert r.read() == b'hellotheresirfinalfantasy'
+        assert r.read() == b''
+
+        assert c._sock is None
+
 
     def test_response_with_body(self):
         self.set_up()