Add unit tests

Author: tannewt

adafruit_requests.py

@@ -429,7 +429,7 @@ def _get_socket(self, host, port, proto, *, timeout=1):
                 if any(self._socket_free.items()):
                     self._free_sockets()
                 else:
-                    raise RuntimeError("Out of sockets")
+                    raise RuntimeError("Sending request failed")
             retry_count += 1
 
             try:
@@ -450,7 +450,7 @@ def _get_socket(self, host, port, proto, *, timeout=1):
             except MemoryError:
                 sock.close()
                 sock = None
-            except OSError as e:
+            except OSError:
                 sock.close()
                 sock = None
 
@@ -619,8 +619,8 @@ def connect(self, address):
         """connect wrapper to add non-standard mode parameter"""
         try:
             return self._socket.connect(address, self._mode)
-        except RuntimeError as e:
-            raise OSError(errno.ENOMEM)
+        except RuntimeError as error:
+            raise OSError(errno.ENOMEM) from error
 
 
 class _FakeSSLContext:

tests/concurrent_test.py

@@ -0,0 +1,86 @@
+from unittest import mock
+import mocket
+import pytest
+import errno
+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_second_connect_fails_memoryerror():
+    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.call_count = 0  # Reset call count
+    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"testwifi/index.html"),]
+    )
+
+    sock.send.assert_has_calls(
+        [mock.call(b"Host: "), mock.call(b"wifitest.adafruit.com"), mock.call(b"\r\n"),]
+    )
+    assert r.text == str(text, "utf-8")
+
+    host2 = "test.adafruit.com"
+    s.get("https://" + host2 + path)
+
+    sock.connect.assert_called_once_with((host, 443))
+    sock2.connect.assert_called_once_with((host2, 443))
+    sock3.connect.assert_called_once_with((host2, 443))
+    # Make sure that the socket is closed after send fails.
+    sock.close.assert_called_once()
+    sock2.close.assert_called_once()
+    assert sock3.close.call_count == 0
+    assert pool.socket.call_count == 3
+
+
+def test_second_connect_fails_oserror():
+    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.call_count = 0  # Reset call count
+    pool.socket.side_effect = [sock, sock2, sock3]
+    sock2.connect.side_effect = OSError(errno.ENOMEM)
+
+    ssl = mocket.SSLContext()
+
+    s = adafruit_requests.Session(pool, ssl)
+    r = s.get("https://" + host + path)
+
+    sock.send.assert_has_calls(
+        [mock.call(b"testwifi/index.html"),]
+    )
+
+    sock.send.assert_has_calls(
+        [mock.call(b"Host: "), mock.call(b"wifitest.adafruit.com"), mock.call(b"\r\n"),]
+    )
+    assert r.text == str(text, "utf-8")
+
+    host2 = "test.adafruit.com"
+    s.get("https://" + host2 + path)
+
+    sock.connect.assert_called_once_with((host, 443))
+    sock2.connect.assert_called_once_with((host2, 443))
+    sock3.connect.assert_called_once_with((host2, 443))
+    # Make sure that the socket is closed after send fails.
+    sock.close.assert_called_once()
+    sock2.close.assert_called_once()
+    assert sock3.close.call_count == 0
+    assert pool.socket.call_count == 3

tests/legacy_mocket.py

@@ -16,11 +16,15 @@ def __init__(self, response):
         self.send = mock.Mock(side_effect=self._send)
         self.readline = mock.Mock(side_effect=self._readline)
         self.recv = mock.Mock(side_effect=self._recv)
+        self.fail_next_send = False
         self._response = response
         self._position = 0
 
     def _send(self, data):
-        return len(data)
+        if self.fail_next_send:
+            self.fail_next_send = False
+            raise RuntimeError("Send failed")
+        return None
 
     def _readline(self):
         i = self._response.find(b"\r\n", self._position)
@@ -32,4 +36,5 @@ def _recv(self, count):
         end = self._position + count
         r = self._response[self._position : end]
         self._position = end
+        print(r)
         return r

tests/legacy_test.py

@@ -1,6 +1,7 @@
 from unittest import mock
 import legacy_mocket as mocket
 import json
+import pytest
 import adafruit_requests
 
 ip = "1.2.3.4"
@@ -49,3 +50,122 @@ def test_post_string():
     sock.connect.assert_called_once_with((ip, 80))
     sock.send.assert_called_with(b"31F")
     r.close()
+
+
+def test_second_tls_send_fails():
+    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(headers + encoded)
+    sock2 = mocket.Mocket(headers + encoded)
+    mocket.socket.call_count = 0  # Reset call count
+    mocket.socket.side_effect = [sock, sock2]
+
+    adafruit_requests.set_socket(mocket, mocket.interface)
+    r = adafruit_requests.get("https://" + host + "/testwifi/index.html")
+
+    sock.send.assert_has_calls(
+        [mock.call(b"testwifi/index.html"),]
+    )
+
+    sock.send.assert_has_calls(
+        [mock.call(b"Host: "), mock.call(host.encode("utf-8")), mock.call(b"\r\n"),]
+    )
+    assert r.text == str(encoded, "utf-8")
+
+    sock.fail_next_send = True
+    adafruit_requests.get("https://" + host + "/get2")
+
+    sock.connect.assert_called_once_with((host, 443), mocket.interface.TLS_MODE)
+    sock2.connect.assert_called_once_with((host, 443), mocket.interface.TLS_MODE)
+    # Make sure that the socket is closed after send fails.
+    sock.close.assert_called_once()
+    assert sock2.close.call_count == 0
+    assert mocket.socket.call_count == 2
+
+
+def test_second_send_fails():
+    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(headers + encoded)
+    sock2 = mocket.Mocket(headers + encoded)
+    mocket.socket.call_count = 0  # Reset call count
+    mocket.socket.side_effect = [sock, sock2]
+
+    adafruit_requests.set_socket(mocket, mocket.interface)
+    r = adafruit_requests.get("http://" + host + "/testwifi/index.html")
+
+    sock.send.assert_has_calls(
+        [mock.call(b"testwifi/index.html"),]
+    )
+
+    sock.send.assert_has_calls(
+        [mock.call(b"Host: "), mock.call(host.encode("utf-8")), mock.call(b"\r\n"),]
+    )
+    assert r.text == str(encoded, "utf-8")
+
+    sock.fail_next_send = True
+    adafruit_requests.get("http://" + host + "/get2")
+
+    sock.connect.assert_called_once_with((ip, 80))
+    sock2.connect.assert_called_once_with((ip, 80))
+    # Make sure that the socket is closed after send fails.
+    sock.close.assert_called_once()
+    assert sock2.close.call_count == 0
+    assert mocket.socket.call_count == 2
+
+
+def test_first_read_fails():
+    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(b"")
+    mocket.socket.call_count = 0  # Reset call count
+    mocket.socket.side_effect = [sock]
+
+    adafruit_requests.set_socket(mocket, mocket.interface)
+
+    with pytest.raises(RuntimeError):
+        r = adafruit_requests.get("http://" + host + "/testwifi/index.html")
+
+    sock.send.assert_has_calls(
+        [mock.call(b"testwifi/index.html"),]
+    )
+
+    sock.send.assert_has_calls(
+        [mock.call(b"Host: "), mock.call(host.encode("utf-8")), mock.call(b"\r\n"),]
+    )
+
+    sock.connect.assert_called_once_with((ip, 80))
+    # Make sure that the socket is closed after the first receive fails.
+    sock.close.assert_called_once()
+    assert mocket.socket.call_count == 1
+
+
+def test_second_tls_connect_fails():
+    mocket.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
+    sock = mocket.Mocket(headers + encoded)
+    sock2 = mocket.Mocket(headers + encoded)
+    sock3 = mocket.Mocket(headers + encoded)
+    mocket.socket.call_count = 0  # Reset call count
+    mocket.socket.side_effect = [sock, sock2, sock3]
+    sock2.connect.side_effect = RuntimeError("error connecting")
+
+    adafruit_requests.set_socket(mocket, mocket.interface)
+    r = adafruit_requests.get("https://" + host + "/testwifi/index.html")
+
+    sock.send.assert_has_calls(
+        [mock.call(b"testwifi/index.html"),]
+    )
+
+    sock.send.assert_has_calls(
+        [mock.call(b"Host: "), mock.call(host.encode("utf-8")), mock.call(b"\r\n"),]
+    )
+    assert r.text == str(encoded, "utf-8")
+
+    host2 = "test.adafruit.com"
+    r = adafruit_requests.get("https://" + host2 + "/get2")
+
+    sock.connect.assert_called_once_with((host, 443), mocket.interface.TLS_MODE)
+    sock2.connect.assert_called_once_with((host2, 443), mocket.interface.TLS_MODE)
+    sock3.connect.assert_called_once_with((host2, 443), mocket.interface.TLS_MODE)
+    # Make sure that the socket is closed after send fails.
+    sock.close.assert_called_once()
+    sock2.close.assert_called_once()
+    assert sock3.close.call_count == 0
+    assert mocket.socket.call_count == 3

tests/mocket.py

@@ -20,8 +20,12 @@ def __init__(self, response):
         self.recv_into = mock.Mock(side_effect=self._recv_into)
         self._response = response
         self._position = 0
+        self.fail_next_send = False
 
     def _send(self, data):
+        if self.fail_next_send:
+            self.fail_next_send = False
+            return 0
         return len(data)
 
     def _readline(self):

tests/reuse_test.py

@@ -143,8 +143,10 @@ def test_connect_out_of_memory():
 def test_second_send_fails():
     pool = mocket.MocketPool()
     pool.getaddrinfo.return_value = ((None, None, None, None, (ip, 80)),)
-    sock = mocket.Mocket(response + response)
-    pool.socket.return_value = sock
+    sock = mocket.Mocket(response)
+    sock2 = mocket.Mocket(response)
+    pool.socket.side_effect = [sock, sock2]
+
     ssl = mocket.SSLContext()
 
     s = adafruit_requests.Session(pool, ssl)
@@ -159,13 +161,12 @@ def test_second_send_fails():
     )
     assert r.text == str(text, "utf-8")
 
-    sock.send.side_effect = None
-    sock.send.return_value = 0
-
-    with pytest.raises(RuntimeError):
-        s.get("https://" + host + path + "2")
+    sock.fail_next_send = True
+    s.get("https://" + host + path + "2")
 
     sock.connect.assert_called_once_with((host, 443))
+    sock2.connect.assert_called_once_with((host, 443))
     # Make sure that the socket is closed after send fails.
     sock.close.assert_called_once()
-    pool.socket.assert_called_once()
+    assert sock2.close.call_count == 0
+    assert pool.socket.call_count == 2