Initial HTTP/1.1 integration tests.

Author: Lukasa

hyper/http11/response.py

@@ -47,7 +47,7 @@ def __init__(self, code, reason, headers, sock):
 
         # The expected length of the body.
         try:
-            self._length = int(self.headers.get(b'content-length', [0])[0])
+            self._length = int(self.headers[b'content-length'][0])
         except KeyError:
             self._length = None
 
@@ -99,8 +99,8 @@ def read(self, amt=None, decode_content=True):
             if self._length is not None:
                 amt = self._length
             elif self._expect_close:
-                return self._read_expect_closed()
-            else:
+                return self._read_expect_closed(decode_content)
+            else:  # pragma: no cover
                 raise RuntimeError("Unbounded read!")
 
         # Otherwise, we've been asked to do a bounded read. We should read no
@@ -130,7 +130,7 @@ def read(self, amt=None, decode_content=True):
             # FIXME: Real exception, not RuntimeError
             if not chunk:
                 self.close()
-                raise RuntimeError("Remote end hung up!")
+                raise ConnectionResetError("Remote end hung up!")
 
             to_read -= len(chunk)
             chunks.append(chunk)
@@ -163,7 +163,7 @@ def close(self):
         self._sock.close()
         self._sock = None
 
-    def _read_expect_closed(self):
+    def _read_expect_closed(self, decode_content):
         """
         Implements the logic for an unbounded read on a socket that we expect
         to be closed by the remote end.
@@ -172,11 +172,14 @@ def _read_expect_closed(self):
         # socket, becuase we know we have to.
         chunks = []
         while True:
-            chunk = self._sock.recv(65535).tobytes()
-            if not chunk:
+            try:
+                chunk = self._sock.recv(65535).tobytes()
+                if not chunk:
+                    break
+            except ConnectionResetError:
                 break
-
-            chunks.append(chunk)
+            else:
+                chunks.append(chunk)
 
         self.close()
 

test/server.py

@@ -18,6 +18,7 @@
 
 from hyper import HTTP20Connection
 from hyper.compat import ssl
+from hyper.http11.connection import HTTP11Connection
 from hyper.http20.hpack import Encoder
 from hyper.http20.huffman import HuffmanEncoder
 from hyper.http20.huffman_constants import (
@@ -34,15 +35,19 @@ class SocketServerThread(threading.Thread):
     :param ready_event: Event which gets set when the socket handler is
         ready to receive requests.
     """
-    def __init__(self, socket_handler, host='localhost', ready_event=None):
+    def __init__(self,
+                 socket_handler,
+                 host='localhost',
+                 ready_event=None,
+                 h2=True):
         threading.Thread.__init__(self)
 
         self.socket_handler = socket_handler
         self.host = host
         self.ready_event = ready_event
 
         self.cxt = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
-        if ssl.HAS_NPN:
+        if ssl.HAS_NPN and h2:
             self.cxt.set_npn_protocols([NPN_PROTOCOL])
         self.cxt.load_cert_chain(certfile='test/certs/server.crt',
                                  keyfile='test/certs/server.key')
@@ -89,14 +94,18 @@ def _start_server(self, socket_handler):
         self.server_thread = SocketServerThread(
             socket_handler=socket_handler,
             ready_event=ready_event,
+            h2=self.h2,
         )
         self.server_thread.start()
         ready_event.wait()
         self.host = self.server_thread.host
         self.port = self.server_thread.port
 
     def get_connection(self):
-        return HTTP20Connection(self.host, self.port)
+        if self.h2:
+            return HTTP20Connection(self.host, self.port)
+        else:
+            return HTTP11Connection(self.host, self.port, secure=True)
 
     def get_encoder(self):
         """

test/test_http11.py

@@ -55,6 +55,13 @@ def test_initialization_separate_port(self):
         assert c.port == 8080
         assert not c.secure
 
+    def test_can_override_security(self):
+        c = HTTP11Connection('localhost', 443, secure=False)
+
+        assert c.host == 'localhost'
+        assert c.port == 443
+        assert not c.secure
+
     def test_basic_request(self):
         c = HTTP11Connection('http2bin.org')
         c._sock = sock = DummySocket()
@@ -309,7 +316,7 @@ def body():
 
 class TestHTTP11Response(object):
     def test_short_circuit_read(self):
-        r = HTTP11Response(200, 'OK', {}, None)
+        r = HTTP11Response(200, 'OK', {b'content-length': [b'0']}, None)
 
         assert r.read() == b''
 

test/test_integration.py

@@ -59,6 +59,9 @@ def receive_preamble(sock):
 
 
 class TestHyperIntegration(SocketLevelTest):
+    # These are HTTP/2 tests.
+    h2 = True
+
     def test_connection_string(self):
         self.set_up()
 

test/test_integration_http11.py

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+"""
+test/integration_http11
+~~~~~~~~~~~~~~~~~~~~~~~
+
+This file defines integration-type tests for hyper's HTTP/1.1 layer. These are
+still not fully hitting the network, so that's alright.
+"""
+import hyper
+import threading
+
+from hyper.compat import ssl
+from hyper.http11.connection import HTTP11Connection
+from server import SocketLevelTest
+
+# Turn off certificate verification for the tests.
+if ssl is not None:
+    hyper.tls._context = hyper.tls._init_context()
+    hyper.tls._context.check_hostname = False
+    hyper.tls._context.verify_mode = ssl.CERT_NONE
+
+
+class TestHyperH11Integration(SocketLevelTest):
+    # These are HTTP/1.1 tests.
+    h2 = False
+
+    def test_basic_request_response(self):
+        self.set_up()
+
+        data = []
+
+        def socket_handler(listener):
+            sock = listener.accept()[0]
+
+            # We should get the initial request.
+            data.append(sock.recv(65535))
+
+            # We need to send back a response.
+            resp = (
+                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)
+
+            sock.close()
+
+        self._start_server(socket_handler)
+        c = self.get_connection()
+        c.request('GET', '/')
+        r = c.get_response()
+
+        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''
+
+    def test_closing_response(self):
+        self.set_up()
+
+        data = []
+
+        def socket_handler(listener):
+            sock = listener.accept()[0]
+
+            # We should get the initial request.
+            data.append(sock.recv(65535))
+
+            # We need to send back a response.
+            resp = (
+                b'HTTP/1.1 200 OK\r\n'
+                b'Server: socket-level-server\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)
+        c = self.get_connection()
+        c.request('GET', '/')
+        r = c.get_response()
+
+        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'connection'] == [b'close']
+
+        assert r.read() == b'hellotheresirfinalfantasy'
+
+    def test_response_with_body(self):
+        self.set_up()
+
+        data = []
+
+        def socket_handler(listener):
+            sock = listener.accept()[0]
+
+            # We should get the initial request.
+            data.append(sock.recv(65535))
+
+            # We need to send back a response.
+            resp = (
+                b'HTTP/1.1 200 OK\r\n'
+                b'Server: socket-level-server\r\n'
+                b'Content-Length: 15\r\n'
+                b'\r\n'
+            )
+            sock.send(resp)
+
+            chunks = [
+                b'hello',
+                b'there',
+                b'hello',
+            ]
+
+            for chunk in chunks:
+                sock.send(chunk)
+
+            sock.close()
+
+        self._start_server(socket_handler)
+        c = self.get_connection()
+        c.request('GET', '/')
+        r = c.get_response()
+
+        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'15']
+
+        assert r.read() == b'hellotherehello'