Basic pure-Python parser.

Author: Lukasa

hyper/http11/parser.py

@@ -10,9 +10,6 @@
 from collections import namedtuple
 
 
-Request = namedtuple(
-    'Request', ['method', 'path', 'minor_version', 'headers', 'consumed']
-)
 Response = namedtuple(
     'Response', ['status', 'msg', 'minor_version', 'headers', 'consumed']
 )
@@ -27,25 +24,14 @@ class ParseError(Exception):
 
 class Parser(object):
     """
-    A single HTTP parser object. This object can parse HTTP requests and
-    responses using picohttpparser.
+    A single HTTP parser object.
     This object is not thread-safe, and it does maintain state that is shared
     across parsing requests. For this reason, make sure that access to this
     object is synchronized if you use it across multiple threads.
     """
     def __init__(self):
         pass
 
-    def parse_request(self, buffer):
-        """
-        Parses a single HTTP request from a buffer.
-        :param buffer: A ``memoryview`` object wrapping a buffer containing a
-            HTTP request.
-        :returns: A :class:`Request <hyper.http11.parser.Request>` object, or
-            ``None`` if there is not enough data in the buffer.
-        """
-        pass
-
     def parse_response(self, buffer):
         """
         Parses a single HTTP response from a buffer.
@@ -54,4 +40,43 @@ def parse_response(self, buffer):
         :returns: A :class:`Response <hyper.http11.parser.Response>` object, or
             ``None`` if there is not enough data in the buffer.
         """
-        pass
+        # Begin by copying the data out of the buffer. This is necessary
+        # because as much as possible we want to use the built-in bytestring
+        # methods, rather than looping over the data in Python.
+        temp_buffer = buffer.tobytes()
+
+        index = temp_buffer.find(b'\n')
+        if index == -1:
+            return None
+
+        version, status, reason = temp_buffer[0:index].split(None, 2)
+        if not version.startswith(b'HTTP/1.'):
+            raise ParseError("Not HTTP/1.X!")
+
+        minor_version = int(version[7:])
+        status = int(status)
+        reason = memoryview(reason.strip())
+
+        # Chomp the newline.
+        index += 1
+
+        # Now, parse the headers out.
+        end_index = index
+        headers = []
+
+        while True:
+            end_index = temp_buffer.find(b'\n', index)
+            if end_index == -1:
+                return None
+            elif (end_index - index) <= 1:
+                # Chomp the newline
+                end_index += 1
+                break
+
+            name, value = temp_buffer[index:end_index].split(b':', 1)
+            value = value.strip()
+            headers.append((memoryview(name), memoryview(value)))
+            index = end_index + 1
+
+        resp = Response(status, reason, minor_version, headers, end_index)
+        return resp

test/test_parser.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+"""
+test_http11_parser.py
+~~~~~~~~~~~~~~~~~~~~~
+
+Unit tests for hyper's HTTP/1.1 parser.
+"""
+import hyper
+import pytest
+
+from hyper.http11.parser import Parser, ParseError
+
+
+class TestHTTP11Parser(object):
+    def test_basic_http11_parsing(self):
+        data = (
+            b"HTTP/1.1 200 OK\r\n"
+            b"Server: h2o\r\n"
+            b"content-length: 2\r\n"
+            b"Vary: accept-encoding\r\n"
+            b"\r\n"
+            b"hi"
+        )
+        m = memoryview(data)
+
+        c = Parser()
+        r = c.parse_response(m)
+
+        assert r
+        assert r.status == 200
+        assert r.msg.tobytes() == b'OK'
+        assert r.minor_version == 1
+
+        expected_headers = [
+            (b'Server', b'h2o'),
+            (b'content-length', b'2'),
+            (b'Vary', b'accept-encoding'),
+        ]
+
+        assert len(expected_headers) == len(r.headers)
+
+        for (n1, v1), (n2, v2) in zip(r.headers, expected_headers):
+            assert n1.tobytes() == n2
+            assert v1.tobytes() == v2
+
+        assert r.consumed == len(data) - 2
+
+    def test_short_response_one(self):
+        data = (
+            b"HTTP/1.1 200 OK\r\n"
+            b"Server: h2o\r\n"
+            b"content"
+        )
+        m = memoryview(data)
+
+        c = Parser()
+        r = c.parse_response(m)
+
+        assert r is None
+
+    def test_short_response_two(self):
+        data = (
+            b"HTTP/1.1 "
+        )
+        m = memoryview(data)
+
+        c = Parser()
+        r = c.parse_response(m)
+
+        assert r is None
+
+    def test_invalid_version(self):
+        data = (
+            b"SQP/1 200 OK\r\n"
+            b"Server: h2o\r\n"
+            b"content-length: 2\r\n"
+            b"Vary: accept-encoding\r\n"
+            b"\r\n"
+            b"hi"
+        )
+        m = memoryview(data)
+
+        c = Parser()
+
+        with pytest.raises(ParseError):
+            c.parse_response(m)