Stabilize more tests and fix linters

Author: gerzse

.flake8

@@ -16,6 +16,7 @@ exclude =
 ignore =
     E126
     E203
+    E231
     E701
     E704
     F405

redis/asyncio/connection.py

@@ -1034,7 +1034,7 @@ def parse_url(url: str) -> ConnectKwargs:
                 try:
                     kwargs[name] = parser(value)
                 except (TypeError, ValueError):
-                    raise ValueError(f"Invalid value for `{name}` in connection URL.")
+                    raise ValueError(f"Invalid value for '{name}' in connection URL.")
             else:
                 kwargs[name] = value
 

redis/commands/graph/query_result.py

@@ -1,6 +1,5 @@
 import sys
 from collections import OrderedDict
-from distutils.util import strtobool
 
 # from prettytable import PrettyTable
 from redis import ResponseError
@@ -571,3 +570,19 @@ async def parse_array(self, value):
         """
         scalar = [await self.parse_scalar(value[i]) for i in range(len(value))]
         return scalar
+
+
+def strtobool(val):
+    """
+    Convert a string representation of truth to true (1) or false (0).
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+    """
+    val = val.lower()
+    if val in ("y", "yes", "t", "true", "on", "1"):
+        return True
+    elif val in ("n", "no", "f", "false", "off", "0"):
+        return False
+    else:
+        raise ValueError(f"invalid truth value {val!r}")

redis/connection.py

@@ -992,7 +992,7 @@ def parse_url(url):
                 try:
                     kwargs[name] = parser(value)
                 except (TypeError, ValueError):
-                    raise ValueError(f"Invalid value for `{name}` in connection URL.")
+                    raise ValueError(f"Invalid value for '{name}' in connection URL.")
             else:
                 kwargs[name] = value
 

tests/test_asyncio/test_connect.py

@@ -1,5 +1,4 @@
 import asyncio
-import logging
 import re
 import socket
 import ssl
@@ -14,9 +13,6 @@
 
 from ..ssl_utils import get_ssl_filename
 
-_logger = logging.getLogger(__name__)
-
-
 _CLIENT_NAME = "test-suite-client"
 _CMD_SEP = b"\r\n"
 _SUCCESS_RESP = b"+OK" + _CMD_SEP
@@ -125,7 +121,7 @@ async def test_tcp_ssl_version_mismatch(tcp_address):
             tcp_address,
             certfile=certfile,
             keyfile=keyfile,
-            ssl_version=ssl.TLSVersion.TLSv1_2,
+            maximum_ssl_version=ssl.TLSVersion.TLSv1_2,
         )
     await conn.disconnect()
 
@@ -135,7 +131,8 @@ async def _assert_connect(
     server_address,
     certfile=None,
     keyfile=None,
-    ssl_version=None,
+    minimum_ssl_version=ssl.TLSVersion.TLSv1_2,
+    maximum_ssl_version=ssl.TLSVersion.TLSv1_3,
 ):
     stop_event = asyncio.Event()
     finished = asyncio.Event()
@@ -153,9 +150,8 @@ async def _handler(reader, writer):
     elif certfile:
         host, port = server_address
         context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-        if ssl_version is not None:
-            context.minimum_version = ssl_version
-            context.maximum_version = ssl_version
+        context.minimum_version = minimum_ssl_version
+        context.maximum_version = maximum_ssl_version
         context.load_cert_chain(certfile=certfile, keyfile=keyfile)
         server = await asyncio.start_server(_handler, host=host, port=port, ssl=context)
     else:
@@ -178,23 +174,18 @@ async def _handler(reader, writer):
 
 
 async def _redis_request_handler(reader, writer, stop_event):
-    buffer = b""
     command = None
     command_ptr = None
     fragment_length = None
-    while not stop_event.is_set() or buffer:
-        _logger.info(str(stop_event.is_set()))
-        try:
-            buffer += await asyncio.wait_for(reader.read(1024), timeout=0.5)
-        except TimeoutError:
-            continue
+    while not stop_event.is_set():
+        buffer = await reader.read(1024)
         if not buffer:
-            continue
+            break
         parts = re.split(_CMD_SEP, buffer)
-        buffer = parts[-1]
-        for fragment in parts[:-1]:
+        for fragment in parts:
             fragment = fragment.decode()
-            _logger.info("Command fragment: %s", fragment)
+            if not fragment:
+                continue
 
             if fragment.startswith("*") and command is None:
                 command = [None for _ in range(int(fragment[1:]))]
@@ -214,10 +205,7 @@ async def _redis_request_handler(reader, writer, stop_event):
                 continue
 
             command = " ".join(command)
-            _logger.info("Command %s", command)
             resp = _SUPPORTED_CMDS.get(command, _ERROR_RESP)
-            _logger.info("Response from %s", resp)
             writer.write(resp)
             await writer.drain()
             command = None
-    _logger.info("Exit handler")

tests/test_connect.py

@@ -7,7 +7,7 @@
 
 import pytest
 from redis.connection import Connection, SSLConnection, UnixDomainSocketConnection
-from redis.exceptions import ConnectionError
+from redis.exceptions import RedisError
 
 from .ssl_utils import get_ssl_filename
 
@@ -126,16 +126,16 @@ def test_tcp_ssl_version_mismatch(tcp_address):
         port=port,
         client_name=_CLIENT_NAME,
         ssl_ca_certs=certfile,
-        socket_timeout=10,
+        socket_timeout=3,
         ssl_min_version=ssl.TLSVersion.TLSv1_3,
     )
-    with pytest.raises(ConnectionError):
+    with pytest.raises(RedisError):
         _assert_connect(
             conn,
             tcp_address,
             certfile=certfile,
             keyfile=keyfile,
-            ssl_version=ssl.PROTOCOL_TLSv1_2,
+            maximum_ssl_version=ssl.PROTOCOL_TLSv1_2,
         )
 
 
@@ -164,14 +164,16 @@ def __init__(
         *args,
         certfile=None,
         keyfile=None,
-        ssl_version=ssl.PROTOCOL_TLS,
+        minimum_ssl_version=ssl.TLSVersion.TLSv1_2,
+        maximum_ssl_version=ssl.TLSVersion.TLSv1_3,
         **kw,
     ) -> None:
         self._ready_event = threading.Event()
         self._stop_requested = False
         self._certfile = certfile
         self._keyfile = keyfile
-        self._ssl_version = ssl_version
+        self._minimum_ssl_version = minimum_ssl_version
+        self._maximum_ssl_version = maximum_ssl_version
         super().__init__(*args, **kw)
 
     def service_actions(self):
@@ -193,15 +195,9 @@ def get_request(self):
         newsocket, fromaddr = self.socket.accept()
         context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
         context.load_cert_chain(certfile=self._certfile, keyfile=self._keyfile)
-        context.minimum_version = ssl.TLSVersion.TLSv1_2
-        context.maximum_version = ssl.TLSVersion.TLSv1_3
-        connstream = context.wrap_socket(
-            newsocket,
-            server_side=True,
-            certfile=self._certfile,
-            keyfile=self._keyfile,
-            ssl_version=self._ssl_version,
-        )
+        context.minimum_version = self._minimum_ssl_version
+        context.maximum_version = self._maximum_ssl_version
+        connstream = context.wrap_socket(newsocket, server_side=True)
         return connstream, fromaddr