redis 5.2.0__tar.gz → 5.2.1__tar.gz

{redis-5.2.0/redis.egg-info → redis-5.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis
-Version: 5.2.0
+Version: 5.2.1
 Summary: Python client for Redis database and key-value store
 Home-page: https://github.com/redis/redis-py
 Author: Redis Inc.

{redis-5.2.0 → redis-5.2.1}/redis/_parsers/helpers.py

@@ -396,13 +396,20 @@ def parse_slowlog_get(response, **options):
         # an O(N) complexity) instead of the command.
         if isinstance(item[3], list):
             result["command"] = space.join(item[3])
-            result["client_address"] = item[4]
-            result["client_name"] = item[5]
+
+            # These fields are optional, depends on environment.
+            if len(item) >= 6:
+                result["client_address"] = item[4]
+                result["client_name"] = item[5]
         else:
             result["complexity"] = item[3]
             result["command"] = space.join(item[4])
-            result["client_address"] = item[5]
-            result["client_name"] = item[6]
+
+            # These fields are optional, depends on environment.
+            if len(item) >= 7:
+                result["client_address"] = item[5]
+                result["client_name"] = item[6]
+
         return result
 
     return [parse_item(item) for item in response]

{redis-5.2.0 → redis-5.2.1}/redis/asyncio/connection.py

@@ -214,7 +214,13 @@ class AbstractConnection:
             _warnings.warn(
                 f"unclosed Connection {self!r}", ResourceWarning, source=self
             )
-            self._close()
+
+            try:
+                asyncio.get_running_loop()
+                self._close()
+            except RuntimeError:
+                # No actions been taken if pool already closed.
+                pass
 
     def _close(self):
         """

{redis-5.2.0 → redis-5.2.1}/redis/asyncio/sentinel.py

@@ -29,11 +29,7 @@ class SentinelManagedConnection(Connection):
         super().__init__(**kwargs)
 
     def __repr__(self):
-        pool = self.connection_pool
-        s = (
-            f"<{self.__class__.__module__}.{self.__class__.__name__}"
-            f"(service={pool.service_name}"
-        )
+        s = f"<{self.__class__.__module__}.{self.__class__.__name__}"
         if self.host:
             host_info = f",host={self.host},port={self.port}"
             s += host_info

{redis-5.2.0 → redis-5.2.1/redis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis
-Version: 5.2.0
+Version: 5.2.1
 Summary: Python client for Redis database and key-value store
 Home-page: https://github.com/redis/redis-py
 Author: Redis Inc.

{redis-5.2.0 → redis-5.2.1}/setup.py

@@ -8,7 +8,7 @@ setup(
     long_description_content_type="text/markdown",
     keywords=["Redis", "key-value store", "database"],
     license="MIT",
-    version="5.2.0",
+    version="5.2.1",
     packages=find_packages(
         include=[
             "redis",

{redis-5.2.0 → redis-5.2.1}/tests/conftest.py

@@ -21,7 +21,7 @@ from redis.cache import (
 from redis.connection import Connection, ConnectionInterface, SSLConnection, parse_url
 from redis.exceptions import RedisClusterException
 from redis.retry import Retry
-from tests.ssl_utils import get_ssl_filename
+from tests.ssl_utils import get_tls_certificates
 
 REDIS_INFO = {}
 default_redis_url = "redis://localhost:6379/0"
@@ -103,6 +103,13 @@ def pytest_addoption(parser):
         help="Redis connection string, defaults to `%(default)s`",
     )
 
+    parser.addoption(
+        "--redis-mod-url",
+        default=default_redismod_url,
+        action="store",
+        help="Redis with modules connection string, defaults to `%(default)s`",
+    )
+
     parser.addoption(
         "--protocol",
         default=default_protocol,
@@ -177,14 +184,14 @@ def pytest_sessionstart(session):
     REDIS_INFO["version"] = version
     REDIS_INFO["arch_bits"] = arch_bits
     REDIS_INFO["cluster_enabled"] = cluster_enabled
+    REDIS_INFO["tls_cert_subdir"] = "cluster" if cluster_enabled else "standalone"
     REDIS_INFO["enterprise"] = enterprise
     # store REDIS_INFO in config so that it is available from "condition strings"
     session.config.REDIS_INFO = REDIS_INFO
 
     # module info
-    stack_url = redis_url
-    if stack_url == default_redis_url:
-        stack_url = default_redismod_url
+    stack_url = session.config.getoption("--redis-mod-url")
+
     try:
         stack_info = _get_info(stack_url)
         REDIS_INFO["modules"] = stack_info["modules"]
@@ -325,6 +332,9 @@ def _get_client(
         redis_url = request.config.getoption("--redis-url")
     else:
         redis_url = from_url
+
+    redis_tls_url = request.config.getoption("--redis-ssl-url")
+
     if "protocol" not in redis_url and kwargs.get("protocol") is None:
         kwargs["protocol"] = request.config.getoption("--protocol")
 
@@ -335,15 +345,11 @@ def _get_client(
         connection_class = Connection
         if ssl:
             connection_class = SSLConnection
-            kwargs["ssl_certfile"] = get_ssl_filename("client-cert.pem")
-            kwargs["ssl_keyfile"] = get_ssl_filename("client-key.pem")
-            # When you try to assign "required" as single string
-            # it assigns tuple instead of string.
-            # Probably some reserved keyword
-            # I can't explain how does it work -_-
-            kwargs["ssl_cert_reqs"] = "require" + "d"
-            kwargs["ssl_ca_certs"] = get_ssl_filename("ca-cert.pem")
-            kwargs["port"] = 6666
+            kwargs["ssl_certfile"], kwargs["ssl_keyfile"], kwargs["ssl_ca_certs"] = (
+                get_tls_certificates()
+            )
+            kwargs["ssl_cert_reqs"] = "required"
+            kwargs["port"] = urlparse(redis_tls_url).port
         kwargs["connection_class"] = connection_class
         url_options.update(kwargs)
         pool = redis.ConnectionPool(**url_options)
@@ -393,11 +399,7 @@ def r(request):
 
 @pytest.fixture()
 def stack_url(request):
-    stack_url = request.config.getoption("--redis-url", default=default_redismod_url)
-    if stack_url == default_redis_url:
-        return default_redismod_url
-    else:
-        return stack_url
+    return request.config.getoption("--redis-mod-url", default=default_redismod_url)
 
 
 @pytest.fixture()

redis-5.2.1/tests/ssl_utils.py

@@ -0,0 +1,43 @@
+import enum
+import os
+from collections import namedtuple
+
+CLIENT_CERT_NAME = "client.crt"
+CLIENT_KEY_NAME = "client.key"
+SERVER_CERT_NAME = "redis.crt"
+SERVER_KEY_NAME = "redis.key"
+CA_CERT_NAME = "ca.crt"
+
+
+class CertificateType(str, enum.Enum):
+    client = "client"
+    server = "server"
+
+
+TLSFiles = namedtuple("TLSFiles", ["certfile", "keyfile", "ca_certfile"])
+
+
+def get_tls_certificates(
+    subdir: str = "standalone",
+    cert_type: CertificateType = CertificateType.client,
+):
+    root = os.path.join(os.path.dirname(__file__), "..")
+    cert_subdir = ("dockers", subdir, "tls")
+    cert_dir = os.path.abspath(os.path.join(root, *cert_subdir))
+    if not os.path.isdir(cert_dir):  # github actions package validation case
+        cert_dir = os.path.abspath(os.path.join(root, "..", *cert_subdir))
+        if not os.path.isdir(cert_dir):
+            raise OSError(f"No SSL certificates found. They should be in {cert_dir}")
+
+    if cert_type == CertificateType.client:
+        return TLSFiles(
+            os.path.join(cert_dir, CLIENT_CERT_NAME),
+            os.path.join(cert_dir, CLIENT_KEY_NAME),
+            os.path.join(cert_dir, CA_CERT_NAME),
+        )
+    elif cert_type == CertificateType.server:
+        return TLSFiles(
+            os.path.join(cert_dir, SERVER_CERT_NAME),
+            os.path.join(cert_dir, SERVER_KEY_NAME),
+            os.path.join(cert_dir, CA_CERT_NAME),
+        )

{redis-5.2.0 → redis-5.2.1}/tests/test_asyncio/test_cluster.py

@@ -33,12 +33,11 @@ from tests.conftest import (
     assert_resp_response,
     is_resp2_connection,
     skip_if_redis_enterprise,
-    skip_if_server_version_gte,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
 )
 
-from ..ssl_utils import get_ssl_filename
+from ..ssl_utils import get_tls_certificates
 from .compat import aclosing, mock
 
 pytestmark = pytest.mark.onlycluster
@@ -380,20 +379,22 @@ class TestRedisClusterObj:
         async with RedisCluster.from_url(url) as rc_default:
             # Test default retry
             retry = rc_default.connection_kwargs.get("retry")
+
+            # FIXME: Workaround for https://github.com/redis/redis-py/issues/3030
+            host = rc_default.get_default_node().host
+
             assert isinstance(retry, Retry)
             assert retry._retries == 3
             assert isinstance(retry._backoff, type(default_backoff()))
-            assert rc_default.get_node("127.0.0.1", 16379).connection_kwargs.get(
+            assert rc_default.get_node(host, 16379).connection_kwargs.get(
                 "retry"
-            ) == rc_default.get_node("127.0.0.1", 16380).connection_kwargs.get("retry")
+            ) == rc_default.get_node(host, 16380).connection_kwargs.get("retry")
 
         retry = Retry(ExponentialBackoff(10, 5), 5)
         async with RedisCluster.from_url(url, retry=retry) as rc_custom_retry:
             # Test custom retry
             assert (
-                rc_custom_retry.get_node("127.0.0.1", 16379).connection_kwargs.get(
-                    "retry"
-                )
+                rc_custom_retry.get_node(host, 16379).connection_kwargs.get("retry")
                 == retry
             )
 
@@ -402,9 +403,7 @@ class TestRedisClusterObj:
         ) as rc_no_retries:
             # Test no connection retries
             assert (
-                rc_no_retries.get_node("127.0.0.1", 16379).connection_kwargs.get(
-                    "retry"
-                )
+                rc_no_retries.get_node(host, 16379).connection_kwargs.get("retry")
                 is None
             )
 
@@ -412,7 +411,7 @@ class TestRedisClusterObj:
             url, retry=Retry(NoBackoff(), 0)
         ) as rc_no_retries:
             assert (
-                rc_no_retries.get_node("127.0.0.1", 16379)
+                rc_no_retries.get_node(host, 16379)
                 .connection_kwargs.get("retry")
                 ._retries
                 == 0
@@ -493,8 +492,8 @@ class TestRedisClusterObj:
         Test command execution with nodes flag REPLICAS
         """
         replicas = r.get_replicas()
-        if not replicas:
-            r = await get_mocked_redis_client(default_host, default_port)
+        assert len(replicas) != 0, "This test requires Cluster with 1 replica"
+
         primaries = r.get_primaries()
         mock_all_nodes_resp(r, "PONG")
         assert await r.ping(target_nodes=RedisCluster.REPLICAS) is True
@@ -2804,7 +2803,6 @@ class TestClusterPipeline:
             assert ask_node._free.pop().read_response.await_count
             assert res == ["MOCK_OK"]
 
-    @skip_if_server_version_gte("7.0.0")
     async def test_moved_redirection_on_slave_with_default(
         self, r: RedisCluster
     ) -> None:
@@ -2824,11 +2822,7 @@ class TestClusterPipeline:
             async def parse_response(
                 self, connection: Connection, command: str, **kwargs: Any
             ) -> Any:
-                if (
-                    command == "GET"
-                    and self.host != primary.host
-                    and self.port != primary.port
-                ):
+                if command == "GET" and self.port != primary.port:
                     raise MovedError(moved_error)
 
                 return await parse_response_orig(connection, command, **kwargs)
@@ -2899,9 +2893,7 @@ class TestSSL:
     appropriate port.
     """
 
-    CA_CERT = get_ssl_filename("ca-cert.pem")
-    CLIENT_CERT = get_ssl_filename("client-cert.pem")
-    CLIENT_KEY = get_ssl_filename("client-key.pem")
+    CLIENT_CERT, CLIENT_KEY, CA_CERT = get_tls_certificates("cluster")
 
     @pytest_asyncio.fixture()
     def create_client(self, request: FixtureRequest) -> Callable[..., RedisCluster]:

{redis-5.2.0 → redis-5.2.1}/tests/test_asyncio/test_connect.py

@@ -11,7 +11,7 @@ from redis.asyncio.connection import (
 )
 from redis.exceptions import ConnectionError
 
-from ..ssl_utils import get_ssl_filename
+from ..ssl_utils import CertificateType, get_tls_certificates
 
 _CLIENT_NAME = "test-suite-client"
 _CMD_SEP = b"\r\n"
@@ -57,19 +57,21 @@ async def test_uds_connect(uds_address):
 )
 async def test_tcp_ssl_tls12_custom_ciphers(tcp_address, ssl_ciphers):
     host, port = tcp_address
-    certfile = get_ssl_filename("client-cert.pem")
-    keyfile = get_ssl_filename("client-key.pem")
-    ca_certfile = get_ssl_filename("ca-cert.pem")
+
+    server_certs = get_tls_certificates(cert_type=CertificateType.server)
+
     conn = SSLConnection(
         host=host,
         port=port,
         client_name=_CLIENT_NAME,
-        ssl_ca_certs=ca_certfile,
+        ssl_ca_certs=server_certs.ca_certfile,
         socket_timeout=10,
         ssl_min_version=ssl.TLSVersion.TLSv1_2,
         ssl_ciphers=ssl_ciphers,
     )
-    await _assert_connect(conn, tcp_address, certfile=certfile, keyfile=keyfile)
+    await _assert_connect(
+        conn, tcp_address, certfile=server_certs.certfile, keyfile=server_certs.keyfile
+    )
     await conn.disconnect()
 
 
@@ -86,18 +88,20 @@ async def test_tcp_ssl_tls12_custom_ciphers(tcp_address, ssl_ciphers):
 )
 async def test_tcp_ssl_connect(tcp_address, ssl_min_version):
     host, port = tcp_address
-    certfile = get_ssl_filename("client-cert.pem")
-    keyfile = get_ssl_filename("client-key.pem")
-    ca_certfile = get_ssl_filename("ca-cert.pem")
+
+    server_certs = get_tls_certificates(cert_type=CertificateType.server)
+
     conn = SSLConnection(
         host=host,
         port=port,
         client_name=_CLIENT_NAME,
-        ssl_ca_certs=ca_certfile,
+        ssl_ca_certs=server_certs.ca_certfile,
         socket_timeout=10,
         ssl_min_version=ssl_min_version,
     )
-    await _assert_connect(conn, tcp_address, certfile=certfile, keyfile=keyfile)
+    await _assert_connect(
+        conn, tcp_address, certfile=server_certs.certfile, keyfile=server_certs.keyfile
+    )
     await conn.disconnect()
 
 
@@ -105,8 +109,7 @@ async def test_tcp_ssl_connect(tcp_address, ssl_min_version):
 @pytest.mark.skipif(not ssl.HAS_TLSv1_3, reason="requires TLSv1.3")
 async def test_tcp_ssl_version_mismatch(tcp_address):
     host, port = tcp_address
-    certfile = get_ssl_filename("server-cert.pem")
-    keyfile = get_ssl_filename("server-key.pem")
+    certfile, keyfile, _ = get_tls_certificates(cert_type=CertificateType.server)
     conn = SSLConnection(
         host=host,
         port=port,

{redis-5.2.0 → redis-5.2.1}/tests/test_asyncio/test_cwe_404.py

@@ -208,7 +208,7 @@ async def test_cluster(master_host):
         port = cluster_port + i
         remapped = remap_base + i
         forward_addr = hostname, port
-        proxy = DelayProxy(addr=("127.0.0.1", remapped), redis_addr=forward_addr)
+        proxy = DelayProxy(addr=(hostname, remapped), redis_addr=forward_addr)
         proxies.append(proxy)
 
     def all_clear():
@@ -233,7 +233,7 @@ async def test_cluster(master_host):
             await stack.enter_async_context(p)
 
         r = RedisCluster.from_url(
-            f"redis://127.0.0.1:{remap_base}", address_remap=remap
+            f"redis://{hostname}:{remap_base}", address_remap=remap
         )
         try:
             await r.initialize()

{redis-5.2.0 → redis-5.2.1}/tests/test_asyncio/test_graph.py

@@ -12,7 +12,7 @@ async def decoded_r(create_redis, stack_url):
     return await create_redis(decode_responses=True, url="redis://localhost:6480")
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_bulk(decoded_r):
     with pytest.raises(NotImplementedError):
@@ -20,7 +20,7 @@ async def test_bulk(decoded_r):
         await decoded_r.graph().bulk(foo="bar!")
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_graph_creation(decoded_r: redis.Redis):
     graph = decoded_r.graph()
@@ -66,7 +66,7 @@ async def test_graph_creation(decoded_r: redis.Redis):
     await graph.delete()
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_array_functions(decoded_r: redis.Redis):
     graph = decoded_r.graph()
@@ -90,7 +90,7 @@ async def test_array_functions(decoded_r: redis.Redis):
     assert [a] == result.result_set[0][0]
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_path(decoded_r: redis.Redis):
     node0 = Node(node_id=0, label="L1")
@@ -111,7 +111,7 @@ async def test_path(decoded_r: redis.Redis):
     assert expected_results == result.result_set
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_param(decoded_r: redis.Redis):
     params = [1, 2.3, "str", True, False, None, [0, 1, 2]]
@@ -122,7 +122,7 @@ async def test_param(decoded_r: redis.Redis):
         assert expected_results == result.result_set
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_map(decoded_r: redis.Redis):
     query = "RETURN {a:1, b:'str', c:NULL, d:[1,2,3], e:True, f:{x:1, y:2}}"
@@ -140,7 +140,7 @@ async def test_map(decoded_r: redis.Redis):
     assert actual == expected
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_point(decoded_r: redis.Redis):
     query = "RETURN point({latitude: 32.070794860, longitude: 34.820751118})"
@@ -158,7 +158,7 @@ async def test_point(decoded_r: redis.Redis):
     assert abs(actual["longitude"] - expected_lon) < 0.001
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_index_response(decoded_r: redis.Redis):
     result_set = await decoded_r.graph().query("CREATE INDEX ON :person(age)")
@@ -174,7 +174,7 @@ async def test_index_response(decoded_r: redis.Redis):
         await decoded_r.graph().query("DROP INDEX ON :person(age)")
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_stringify_query_result(decoded_r: redis.Redis):
     graph = decoded_r.graph()
@@ -229,7 +229,7 @@ async def test_stringify_query_result(decoded_r: redis.Redis):
     await graph.delete()
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_optional_match(decoded_r: redis.Redis):
     # Build a graph of form (a)-[R]->(b)
@@ -255,7 +255,7 @@ async def test_optional_match(decoded_r: redis.Redis):
     await graph.delete()
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_cached_execution(decoded_r: redis.Redis):
     await decoded_r.graph().query("CREATE ()")
@@ -276,7 +276,7 @@ async def test_cached_execution(decoded_r: redis.Redis):
     assert cached_result.cached_execution
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_slowlog(decoded_r: redis.Redis):
     create_query = """CREATE
@@ -291,7 +291,7 @@ async def test_slowlog(decoded_r: redis.Redis):
 
 
 @pytest.mark.xfail(strict=False)
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_query_timeout(decoded_r: redis.Redis):
     # Build a sample graph with 1000 nodes.
@@ -306,7 +306,7 @@ async def test_query_timeout(decoded_r: redis.Redis):
         assert False is False
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_read_only_query(decoded_r: redis.Redis):
     with pytest.raises(Exception):
@@ -316,7 +316,7 @@ async def test_read_only_query(decoded_r: redis.Redis):
         assert False is False
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_profile(decoded_r: redis.Redis):
     q = """UNWIND range(1, 3) AS x CREATE (p:Person {v:x})"""
@@ -333,7 +333,7 @@ async def test_profile(decoded_r: redis.Redis):
 
 
 @skip_if_redis_enterprise()
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_config(decoded_r: redis.Redis):
     config_name = "RESULTSET_SIZE"
@@ -366,7 +366,7 @@ async def test_config(decoded_r: redis.Redis):
 
 
 @pytest.mark.onlynoncluster
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_list_keys(decoded_r: redis.Redis):
     result = await decoded_r.graph().list_keys()
@@ -390,7 +390,7 @@ async def test_list_keys(decoded_r: redis.Redis):
     assert result == []
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_multi_label(decoded_r: redis.Redis):
     redis_graph = decoded_r.graph("g")
@@ -417,7 +417,7 @@ async def test_multi_label(decoded_r: redis.Redis):
         assert True
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_execution_plan(decoded_r: redis.Redis):
     redis_graph = decoded_r.graph("execution_plan")
@@ -437,7 +437,7 @@ async def test_execution_plan(decoded_r: redis.Redis):
     await redis_graph.delete()
 
 
-@pytest.mark.redismod
+@pytest.mark.graph
 @skip_if_resp_version(3)
 async def test_explain(decoded_r: redis.Redis):
     redis_graph = decoded_r.graph("execution_plan")

{redis-5.2.0 → redis-5.2.1}/tests/test_asyncio/test_hash.py

@@ -1,4 +1,5 @@
 import asyncio
+import math
 from datetime import datetime, timedelta
 
 from tests.conftest import skip_if_server_version_lt
@@ -128,9 +129,9 @@ async def test_hpexpire_multiple_fields(r):
 async def test_hexpireat_basic(r):
     await r.delete("test:hash")
     await r.hset("test:hash", mapping={"field1": "value1", "field2": "value2"})
-    exp_time = int((datetime.now() + timedelta(seconds=1)).timestamp())
+    exp_time = math.ceil((datetime.now() + timedelta(seconds=1)).timestamp())
     assert await r.hexpireat("test:hash", exp_time, "field1") == [1]
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(2.1)
     assert await r.hexists("test:hash", "field1") is False
     assert await r.hexists("test:hash", "field2") is True
 
@@ -139,9 +140,9 @@ async def test_hexpireat_basic(r):
 async def test_hexpireat_with_datetime(r):
     await r.delete("test:hash")
     await r.hset("test:hash", mapping={"field1": "value1", "field2": "value2"})
-    exp_time = datetime.now() + timedelta(seconds=1)
+    exp_time = (datetime.now() + timedelta(seconds=2)).replace(microsecond=0)
     assert await r.hexpireat("test:hash", exp_time, "field1") == [1]
-    await asyncio.sleep(1.1)
+    await asyncio.sleep(2.1)
     assert await r.hexists("test:hash", "field1") is False
     assert await r.hexists("test:hash", "field2") is True
 
@@ -175,9 +176,9 @@ async def test_hexpireat_multiple_fields(r):
         "test:hash",
         mapping={"field1": "value1", "field2": "value2", "field3": "value3"},
     )
-    exp_time = int((datetime.now() + timedelta(seconds=1)).timestamp())
+    exp_time = math.ceil((datetime.now() + timedelta(seconds=1)).timestamp())
     assert await r.hexpireat("test:hash", exp_time, "field1", "field2") == [1, 1]
-    await asyncio.sleep(1.5)
+    await asyncio.sleep(2.1)
     assert await r.hexists("test:hash", "field1") is False
     assert await r.hexists("test:hash", "field2") is False
     assert await r.hexists("test:hash", "field3") is True

{redis-5.2.0 → redis-5.2.1}/tests/test_asyncio/test_search.py

@@ -1025,6 +1025,8 @@ async def test_phonetic_matcher(decoded_r: redis.Redis):
 
 @pytest.mark.redismod
 @pytest.mark.onlynoncluster
+# NOTE(imalinovskyi): This test contains hardcoded scores valid only for RediSearch 2.8+
+@skip_ifmodversion_lt("2.8.0", "search")
 async def test_scorer(decoded_r: redis.Redis):
     await decoded_r.ft().create_index((TextField("description"),))
 

{redis-5.2.0 → redis-5.2.1}/tests/test_asyncio/test_sentinel.py

@@ -264,3 +264,23 @@ async def test_auto_close_pool(cluster, sentinel, method_name):
 
     assert calls == 1
     await pool.disconnect()
+
+
+@pytest.mark.onlynoncluster
+async def test_repr_correctly_represents_connection_object(sentinel):
+    pool = SentinelConnectionPool("mymaster", sentinel)
+    connection = await pool.get_connection("PING")
+
+    assert (
+        str(connection)
+        == "<redis.asyncio.sentinel.SentinelManagedConnection,host=127.0.0.1,port=6379)>"  # noqa: E501
+    )
+    assert connection.connection_pool == pool
+    await pool.release(connection)
+
+    del pool
+
+    assert (
+        str(connection)
+        == "<redis.asyncio.sentinel.SentinelManagedConnection,host=127.0.0.1,port=6379)>"  # noqa: E501
+    )