Merge pull request #31 from tannewt/http11

Add HTTP1.1 support and socket reuse

Author: tannewt

.github/workflows/test.yml

@@ -6,10 +6,6 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-    - name: Dump GitHub context
-      env:
-        GITHUB_CONTEXT: ${{ toJson(github) }}
-      run: echo "$GITHUB_CONTEXT"
     - name: Set up Python 3.6
       uses: actions/setup-python@v1
       with:

adafruit_requests.py

@@ -5,6 +5,16 @@
 from adafruit_esp32spi import adafruit_esp32spi
 import adafruit_requests as requests
 
+# Add a secrets.py to your filesystem that has a dictionary called secrets with "ssid" and
+# "password" keys with your WiFi credentials. DO NOT share that file or commit it into Git or other
+# source control.
+# pylint: disable=no-name-in-module,wrong-import-order
+try:
+    from secrets import secrets
+except ImportError:
+    print("WiFi secrets are kept in secrets.py, please add them there!")
+    raise
+
 # If you are using a board with pre-defined ESP32 Pins:
 esp32_cs = DigitalInOut(board.ESP_CS)
 esp32_ready = DigitalInOut(board.ESP_BUSY)
@@ -21,14 +31,15 @@
 print("Connecting to AP...")
 while not esp.is_connected:
     try:
-        esp.connect_AP(b"MY_SSID_NAME", b"MY_SSID_PASSWORD")
+        esp.connect_AP(secrets["ssid"], secrets["password"])
     except RuntimeError as e:
         print("could not connect to AP, retrying: ", e)
         continue
 print("Connected to", str(esp.ssid, "utf-8"), "\tRSSI:", esp.rssi)
 
 # Initialize a requests object with a socket and esp32spi interface
-requests.set_socket(socket, esp)
+socket.set_interface(esp)
+requests.set_socket(socket)
 
 JSON_GET_URL = "http://httpbin.org/get"
 

examples/requests_advanced.py

@@ -0,0 +1,28 @@
+import socket
+import adafruit_requests
+
+http = adafruit_requests.Session(socket)
+
+JSON_GET_URL = "http://httpbin.org/get"
+
+# Define a custom header as a dict.
+headers = {"user-agent": "blinka/1.0.0"}
+
+print("Fetching JSON data from %s..." % JSON_GET_URL)
+response = http.get(JSON_GET_URL, headers=headers)
+print("-" * 60)
+
+json_data = response.json()
+headers = json_data["headers"]
+print("Response's Custom User-Agent Header: {0}".format(headers["User-Agent"]))
+print("-" * 60)
+
+# Read Response's HTTP status code
+print("Response HTTP Status Code: ", response.status_code)
+print("-" * 60)
+
+# Read Response, as raw bytes instead of pretty text
+print("Raw Response: ", response.content)
+
+# Close, delete and collect the response data
+response.close()

examples/requests_advanced_cpython.py

@@ -0,0 +1,13 @@
+# adafruit_requests usage with a CPython socket
+import socket
+import ssl
+import adafruit_requests
+
+http = adafruit_requests.Session(socket, ssl.create_default_context())
+
+print("Getting CircuitPython star count")
+headers = {"Transfer-Encoding": "chunked"}
+response = http.get(
+    "https://api.github.com/repos/adafruit/circuitpython", headers=headers
+)
+print("circuitpython stars", response.json()["stargazers_count"])

examples/requests_github_cpython.py

@@ -0,0 +1,45 @@
+# adafruit_requests usage with a CPython socket
+import socket
+import ssl
+import adafruit_requests as requests
+
+https = requests.Session(socket, ssl.create_default_context())
+
+TEXT_URL = "https://wifitest.adafruit.com/testwifi/index.html"
+JSON_GET_URL = "https://httpbin.org/get"
+JSON_POST_URL = "https://httpbin.org/post"
+
+# print("Fetching text from %s" % TEXT_URL)
+# response = requests.get(TEXT_URL)
+# print("-" * 40)
+
+# print("Text Response: ", response.text)
+# print("-" * 40)
+# response.close()
+
+print("Fetching JSON data from %s" % JSON_GET_URL)
+response = https.get(JSON_GET_URL)
+print("-" * 40)
+
+print("JSON Response: ", response.json())
+print("-" * 40)
+
+data = "31F"
+print("POSTing data to {0}: {1}".format(JSON_POST_URL, data))
+response = https.post(JSON_POST_URL, data=data)
+print("-" * 40)
+
+json_resp = response.json()
+# Parse out the 'data' key from json_resp dict.
+print("Data received from server:", json_resp["data"])
+print("-" * 40)
+
+json_data = {"Date": "July 25, 2019"}
+print("POSTing data to {0}: {1}".format(JSON_POST_URL, json_data))
+response = https.post(JSON_POST_URL, json=json_data)
+print("-" * 40)
+
+json_resp = response.json()
+# Parse out the 'json' key from json_resp dict.
+print("JSON Data received from server:", json_resp["json"])
+print("-" * 40)

examples/requests_https_cpython.py

@@ -6,6 +6,16 @@
 from adafruit_esp32spi import adafruit_esp32spi
 import adafruit_requests as requests
 
+# Add a secrets.py to your filesystem that has a dictionary called secrets with "ssid" and
+# "password" keys with your WiFi credentials. DO NOT share that file or commit it into Git or other
+# source control.
+# pylint: disable=no-name-in-module,wrong-import-order
+try:
+    from secrets import secrets
+except ImportError:
+    print("WiFi secrets are kept in secrets.py, please add them there!")
+    raise
+
 # If you are using a board with pre-defined ESP32 Pins:
 esp32_cs = DigitalInOut(board.ESP_CS)
 esp32_ready = DigitalInOut(board.ESP_BUSY)
@@ -22,14 +32,15 @@
 print("Connecting to AP...")
 while not esp.is_connected:
     try:
-        esp.connect_AP(b"MY_SSID_NAME", b"MY_SSID_PASSWORD")
+        esp.connect_AP(secrets["ssid"], secrets["password"])
     except RuntimeError as e:
         print("could not connect to AP, retrying: ", e)
         continue
 print("Connected to", str(esp.ssid, "utf-8"), "\tRSSI:", esp.rssi)
 
 # Initialize a requests object with a socket and esp32spi interface
-requests.set_socket(socket, esp)
+socket.set_interface(esp)
+requests.set_socket(socket)
 
 TEXT_URL = "http://wifitest.adafruit.com/testwifi/index.html"
 JSON_GET_URL = "http://httpbin.org/get"

examples/requests_simpletest.py

@@ -0,0 +1,44 @@
+# adafruit_requests usage with a CPython socket
+import socket
+import adafruit_requests
+
+http = adafruit_requests.Session(socket)
+
+TEXT_URL = "http://wifitest.adafruit.com/testwifi/index.html"
+JSON_GET_URL = "http://httpbin.org/get"
+JSON_POST_URL = "http://httpbin.org/post"
+
+print("Fetching text from %s" % TEXT_URL)
+response = http.get(TEXT_URL)
+print("-" * 40)
+
+print("Text Response: ", response.text)
+print("-" * 40)
+
+print("Fetching JSON data from %s" % JSON_GET_URL)
+response = http.get(JSON_GET_URL)
+print("-" * 40)
+
+print("JSON Response: ", response.json())
+print("-" * 40)
+response.close()
+
+data = "31F"
+print("POSTing data to {0}: {1}".format(JSON_POST_URL, data))
+response = http.post(JSON_POST_URL, data=data)
+print("-" * 40)
+
+json_resp = response.json()
+# Parse out the 'data' key from json_resp dict.
+print("Data received from server:", json_resp["data"])
+print("-" * 40)
+
+json_data = {"Date": "July 25, 2019"}
+print("POSTing data to {0}: {1}".format(JSON_POST_URL, json_data))
+response = http.post(JSON_POST_URL, json=json_data)
+print("-" * 40)
+
+json_resp = response.json()
+# Parse out the 'json' key from json_resp dict.
+print("JSON Data received from server:", json_resp["json"])
+print("-" * 40)

examples/requests_simpletest_cpython.py

@@ -0,0 +1,48 @@
+from unittest import mock
+import mocket
+import adafruit_requests
+
+ip = "1.2.3.4"
+host = "wifitest.adafruit.com"
+path = "/testwifi/index.html"
+text = b"This is a test of Adafruit WiFi!\r\nIf you can read this, its working :)"
+headers = b"HTTP/1.0 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
+
+
+def _chunk(response, split):
+    i = 0
+    chunked = b""
+    while i < len(response):
+        remaining = len(response) - i
+        chunk_size = split
+        if remaining < chunk_size:
+            chunk_size = remaining
+        new_i = i + chunk_size
+        chunked += (
+            hex(chunk_size)[2:].encode("ascii") + b"\r\n" + response[i:new_i] + b"\r\n"
+        )
+        i = new_i
+    # The final chunk is zero length.
+    chunked += b"0\r\n\r\n"
+    return chunked
+
+
+def test_get_text():
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    c = _chunk(text, 33)
+    print(c)
+    sock = mocket.Mocket(headers + c)
+    pool.socket.return_value = sock
+
+    s = adafruit_requests.Session(pool)
+    r = s.get("http://" + host + path)
+
+    sock.connect.assert_called_once_with((ip, 80))
+    sock.send.assert_has_calls(
+        [
+            mock.call(b"GET /testwifi/index.html HTTP/1.1\r\n"),
+            mock.call(b"Host: wifitest.adafruit.com\r\n"),
+        ]
+    )
+    assert r.text == str(text, "utf-8")

tests/chunk_test.py

@@ -9,17 +9,18 @@
 
 
 def test_json():
-    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
     sock = mocket.Mocket(response_headers)
-    mocket.socket.return_value = sock
+    pool.socket.return_value = sock
     sent = []
     sock.send.side_effect = sent.append
 
-    adafruit_requests.set_socket(mocket, mocket.interface)
+    s = adafruit_requests.Session(pool)
     headers = {"user-agent": "blinka/1.0.0"}
-    r = adafruit_requests.get("http://" + host + "/get", headers=headers)
+    r = s.get("http://" + host + "/get", headers=headers)
 
-    sock.connect.assert_called_once_with((ip, 80), mocket.interface.TCP_MODE)
+    sock.connect.assert_called_once_with((ip, 80))
     sent = b"".join(sent).lower()
     assert b"user-agent: blinka/1.0.0\r\n" in sent
     # The current implementation sends two user agents. Fix it, and uncomment below.

tests/header_test.py

@@ -0,0 +1,32 @@
+from unittest import mock
+
+SOCK_STREAM = 0
+
+set_interface = mock.Mock()
+interface = mock.MagicMock()
+getaddrinfo = mock.Mock()
+socket = mock.Mock()
+
+
+class Mocket:
+    def __init__(self, response):
+        self.settimeout = mock.Mock()
+        self.close = mock.Mock()
+        self.connect = mock.Mock()
+        self.send = mock.Mock()
+        self.readline = mock.Mock(side_effect=self._readline)
+        self.recv = mock.Mock(side_effect=self._recv)
+        self._response = response
+        self._position = 0
+
+    def _readline(self):
+        i = self._response.find(b"\r\n", self._position)
+        r = self._response[self._position : i + 2]
+        self._position = i + 2
+        return r
+
+    def _recv(self, count):
+        end = self._position + count
+        r = self._response[self._position : end]
+        self._position = end
+        return r

tests/legacy_mocket.py

@@ -0,0 +1,51 @@
+from unittest import mock
+import legacy_mocket as mocket
+import json
+import adafruit_requests
+
+ip = "1.2.3.4"
+host = "httpbin.org"
+response = {"Date": "July 25, 2019"}
+encoded = json.dumps(response).encode("utf-8")
+headers = "HTTP/1.0 200 OK\r\nContent-Length: {}\r\n\r\n".format(len(encoded)).encode(
+    "utf-8"
+)
+
+
+def test_get_json():
+    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(headers + encoded)
+    mocket.socket.return_value = sock
+
+    adafruit_requests.set_socket(mocket, mocket.interface)
+    r = adafruit_requests.get("http://" + host + "/get")
+
+    sock.connect.assert_called_once_with((ip, 80))
+    assert r.json() == response
+    r.close()
+
+
+def test_tls_mode():
+    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(headers + encoded)
+    mocket.socket.return_value = sock
+
+    adafruit_requests.set_socket(mocket, mocket.interface)
+    r = adafruit_requests.get("https://" + host + "/get")
+
+    sock.connect.assert_called_once_with((host, 443), mocket.interface.TLS_MODE)
+    assert r.json() == response
+    r.close()
+
+
+def test_post_string():
+    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(headers + encoded)
+    mocket.socket.return_value = sock
+
+    adafruit_requests.set_socket(mocket, mocket.interface)
+    data = "31F"
+    r = adafruit_requests.post("http://" + host + "/post", data=data)
+    sock.connect.assert_called_once_with((ip, 80))
+    sock.send.assert_called_with(b"31F")
+    r.close()

tests/legacy_test.py

@@ -1,12 +1,12 @@
 from unittest import mock
 
-SOCK_STREAM = 0
 
-getaddrinfo = mock.Mock()
-socket = mock.Mock()
-set_interface = mock.Mock()
+class MocketPool:
+    SOCK_STREAM = 0
 
-interface = mock.MagicMock()
+    def __init__(self):
+        self.getaddrinfo = mock.Mock()
+        self.socket = mock.Mock()
 
 
 class Mocket:
@@ -17,6 +17,7 @@ def __init__(self, response):
         self.send = mock.Mock()
         self.readline = mock.Mock(side_effect=self._readline)
         self.recv = mock.Mock(side_effect=self._recv)
+        self.recv_into = mock.Mock(side_effect=self._recv_into)
         self._response = response
         self._position = 0
 
@@ -31,3 +32,22 @@ def _recv(self, count):
         r = self._response[self._position : end]
         self._position = end
         return r
+
+    def _recv_into(self, buf, nbytes=0):
+        assert isinstance(nbytes, int) and nbytes >= 0
+        read = nbytes if nbytes > 0 else len(buf)
+        remaining = len(self._response) - self._position
+        if read > remaining:
+            read = remaining
+        end = self._position + read
+        buf[:read] = self._response[self._position : end]
+        self._position = end
+        return read
+
+
+class SSLContext:
+    def __init__(self):
+        self.wrap_socket = mock.Mock(side_effect=self._wrap_socket)
+
+    def _wrap_socket(self, sock, server_hostname=None):
+        return sock

tests/mocket.py

@@ -7,17 +7,22 @@
 host = "httpbin.org"
 response = {"Date": "July 25, 2019"}
 encoded = json.dumps(response).encode("utf-8")
-headers = "HTTP/1.0 200 OK\r\nContent-Length: {}\r\n\r\n".format(len(encoded)).encode(
+# Padding here tests the case where a header line is exactly 32 bytes buffered by
+# aligning the Content-Type header after it.
+headers = "HTTP/1.0 200 OK\r\npadding: 000\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n".format(
+    len(encoded)
+).encode(
     "utf-8"
 )
 
 
 def test_json():
-    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
     sock = mocket.Mocket(headers + encoded)
-    mocket.socket.return_value = sock
+    pool.socket.return_value = sock
 
-    adafruit_requests.set_socket(mocket, mocket.interface)
-    r = adafruit_requests.get("http://" + host + "/get")
-    sock.connect.assert_called_once_with((ip, 80), mocket.interface.TCP_MODE)
+    s = adafruit_requests.Session(pool)
+    r = s.get("http://" + host + "/get")
+    sock.connect.assert_called_once_with((ip, 80))
     assert r.json() == response

tests/parse_test.py

@@ -13,37 +13,53 @@
 
 
 def test_method():
-    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
     sock = mocket.Mocket(headers + encoded)
-    mocket.socket.return_value = sock
+    pool.socket.return_value = sock
 
-    adafruit_requests.set_socket(mocket, mocket.interface)
-    r = adafruit_requests.post("http://" + host + "/post")
-    sock.connect.assert_called_once_with((ip, 80), mocket.interface.TCP_MODE)
+    s = adafruit_requests.Session(pool)
+    r = s.post("http://" + host + "/post")
+    sock.connect.assert_called_once_with((ip, 80))
     sock.send.assert_has_calls(
-        [mock.call(b"POST /post HTTP/1.0\r\n"), mock.call(b"Host: httpbin.org\r\n")]
+        [mock.call(b"POST /post HTTP/1.1\r\n"), mock.call(b"Host: httpbin.org\r\n")]
     )
 
 
 def test_string():
-    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
     sock = mocket.Mocket(headers + encoded)
-    mocket.socket.return_value = sock
+    pool.socket.return_value = sock
 
-    adafruit_requests.set_socket(mocket, mocket.interface)
+    s = adafruit_requests.Session(pool)
     data = "31F"
-    r = adafruit_requests.post("http://" + host + "/post", data=data)
-    sock.connect.assert_called_once_with((ip, 80), mocket.interface.TCP_MODE)
+    r = s.post("http://" + host + "/post", data=data)
+    sock.connect.assert_called_once_with((ip, 80))
     sock.send.assert_called_with(b"31F")
 
 
+def test_form():
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(headers + encoded)
+    pool.socket.return_value = sock
+
+    s = adafruit_requests.Session(pool)
+    data = {"Date": "July 25, 2019"}
+    r = s.post("http://" + host + "/post", data=data)
+    sock.connect.assert_called_once_with((ip, 80))
+    sock.send.assert_called_with(b"Date=July 25, 2019")
+
+
 def test_json():
-    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
     sock = mocket.Mocket(headers + encoded)
-    mocket.socket.return_value = sock
+    pool.socket.return_value = sock
 
-    adafruit_requests.set_socket(mocket, mocket.interface)
+    s = adafruit_requests.Session(pool)
     json_data = {"Date": "July 25, 2019"}
-    r = adafruit_requests.post("http://" + host + "/post", json=json_data)
-    sock.connect.assert_called_once_with((ip, 80), mocket.interface.TCP_MODE)
+    r = s.post("http://" + host + "/post", json=json_data)
+    sock.connect.assert_called_once_with((ip, 80))
     sock.send.assert_called_with(b'{"Date": "July 25, 2019"}')

tests/post_test.py

@@ -1,5 +1,6 @@
 from unittest import mock
 import mocket
+import pytest
 import adafruit_requests
 
 ip = "1.2.3.4"
@@ -9,40 +10,54 @@
 response = b"HTTP/1.0 200 OK\r\nContent-Length: 70\r\n\r\n" + text
 
 
+def test_get_https_no_ssl():
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(response)
+    pool.socket.return_value = sock
+
+    s = adafruit_requests.Session(pool)
+    with pytest.raises(RuntimeError):
+        r = s.get("https://" + host + path)
+
+
 def test_get_https_text():
-    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
     sock = mocket.Mocket(response)
-    mocket.socket.return_value = sock
+    pool.socket.return_value = sock
+    ssl = mocket.SSLContext()
 
-    adafruit_requests.set_socket(mocket, mocket.interface)
-    r = adafruit_requests.get("https://" + host + path)
+    s = adafruit_requests.Session(pool, ssl)
+    r = s.get("https://" + host + path)
 
-    sock.connect.assert_called_once_with((host, 443), mocket.interface.TLS_MODE)
+    sock.connect.assert_called_once_with((host, 443))
     sock.send.assert_has_calls(
         [
-            mock.call(b"GET /testwifi/index.html HTTP/1.0\r\n"),
+            mock.call(b"GET /testwifi/index.html HTTP/1.1\r\n"),
             mock.call(b"Host: wifitest.adafruit.com\r\n"),
         ]
     )
     assert r.text == str(text, "utf-8")
 
+    # Close isn't needed but can be called to release the socket early.
+    r.close()
+
 
 def test_get_http_text():
-    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
     sock = mocket.Mocket(response)
-    mocket.socket.return_value = sock
+    pool.socket.return_value = sock
 
-    adafruit_requests.set_socket(mocket, mocket.interface)
-    r = adafruit_requests.get("http://" + host + path)
+    s = adafruit_requests.Session(pool)
+    r = s.get("http://" + host + path)
 
-    sock.connect.assert_called_once_with((ip, 80), mocket.interface.TCP_MODE)
+    sock.connect.assert_called_once_with((ip, 80))
     sock.send.assert_has_calls(
         [
-            mock.call(b"GET /testwifi/index.html HTTP/1.0\r\n"),
+            mock.call(b"GET /testwifi/index.html HTTP/1.1\r\n"),
             mock.call(b"Host: wifitest.adafruit.com\r\n"),
         ]
     )
     assert r.text == str(text, "utf-8")
-
-
-# Add a chunked response test when we support HTTP 1.1

tests/protocol_test.py

@@ -0,0 +1,107 @@
+from unittest import mock
+import mocket
+import pytest
+import adafruit_requests
+
+ip = "1.2.3.4"
+host = "wifitest.adafruit.com"
+host2 = "wifitest2.adafruit.com"
+path = "/testwifi/index.html"
+text = b"This is a test of Adafruit WiFi!\r\nIf you can read this, its working :)"
+response = b"HTTP/1.0 200 OK\r\nContent-Length: 70\r\n\r\n" + text
+
+# def test_get_twice():
+#     pool = mocket.MocketPool()
+#     pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+#     sock = mocket.Mocket(response + response)
+#     pool.socket.return_value = sock
+#     ssl = mocket.SSLContext()
+
+#     s = adafruit_requests.Session(pool, ssl)
+#     r = s.get("https://" + host + path)
+
+#     sock.send.assert_has_calls(
+#         [
+#             mock.call(b"GET /testwifi/index.html HTTP/1.1\r\n"),
+#             mock.call(b"Host: wifitest.adafruit.com\r\n"),
+#         ]
+#     )
+#     assert r.text == str(text, "utf-8")
+
+#     r = s.get("https://" + host + path + "2")
+#     sock.send.assert_has_calls(
+#         [
+#             mock.call(b"GET /testwifi/index.html2 HTTP/1.1\r\n"),
+#             mock.call(b"Host: wifitest.adafruit.com\r\n"),
+#         ]
+#     )
+
+#     assert r.text == str(text, "utf-8")
+#     sock.connect.assert_called_once_with((host, 443))
+#     pool.socket.assert_called_once()
+
+
+def test_get_twice_after_second():
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(response + response)
+    pool.socket.return_value = sock
+    ssl = mocket.SSLContext()
+
+    s = adafruit_requests.Session(pool, ssl)
+    r = s.get("https://" + host + path)
+
+    sock.send.assert_has_calls(
+        [
+            mock.call(b"GET /testwifi/index.html HTTP/1.1\r\n"),
+            mock.call(b"Host: wifitest.adafruit.com\r\n"),
+        ]
+    )
+
+    r2 = s.get("https://" + host + path + "2")
+    sock.send.assert_has_calls(
+        [
+            mock.call(b"GET /testwifi/index.html2 HTTP/1.1\r\n"),
+            mock.call(b"Host: wifitest.adafruit.com\r\n"),
+        ]
+    )
+    sock.connect.assert_called_once_with((host, 443))
+    pool.socket.assert_called_once()
+
+    with pytest.raises(RuntimeError):
+        r.text == str(text, "utf-8")
+
+
+def test_connect_out_of_memory():
+    pool = mocket.MocketPool()
+    pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(response)
+    sock2 = mocket.Mocket(response)
+    sock3 = mocket.Mocket(response)
+    pool.socket.side_effect = [sock, sock2, sock3]
+    sock2.connect.side_effect = MemoryError()
+    ssl = mocket.SSLContext()
+
+    s = adafruit_requests.Session(pool, ssl)
+    r = s.get("https://" + host + path)
+
+    sock.send.assert_has_calls(
+        [
+            mock.call(b"GET /testwifi/index.html HTTP/1.1\r\n"),
+            mock.call(b"Host: wifitest.adafruit.com\r\n"),
+        ]
+    )
+    assert r.text == str(text, "utf-8")
+
+    r = s.get("https://" + host2 + path)
+    sock3.send.assert_has_calls(
+        [
+            mock.call(b"GET /testwifi/index.html HTTP/1.1\r\n"),
+            mock.call(b"Host: wifitest2.adafruit.com\r\n"),
+        ]
+    )
+
+    assert r.text == str(text, "utf-8")
+    sock.close.assert_called_once()
+    sock.connect.assert_called_once_with((host, 443))
+    sock3.connect.assert_called_once_with((host2, 443))