refactor tests

Author: Andrei Neagu

packages/service-library/src/servicelib/long_running_interfaces/_redis.py

@@ -23,7 +23,7 @@ def __init__(
         long_running_namespace: LongRunningNamespace,
     ) -> None:
         self.long_running_namespace = long_running_namespace
-        self._redis_sdk = RedisClientSDK(
+        self.redis_sdk = RedisClientSDK(
             redis_settings.build_redis_dsn(
                 RedisDatabase.DEFERRED_TASKS  # TODO: requires separate DB for sure
             ),
@@ -38,11 +38,11 @@ async def setup(self) -> None:
         _logger.debug("finished setup")
 
     async def teardown(self) -> None:
-        await self._redis_sdk.shutdown()
+        await self.redis_sdk.shutdown()
 
     async def get(self, unique_id: JobUniqueId) -> ScheduleModel | None:
         key = self._get_key(unique_id)
-        raw_data = await self._redis_sdk.redis.get(key)
+        raw_data = await self.redis_sdk.redis.get(key)
 
         if raw_data is None:
             return None
@@ -53,18 +53,22 @@ async def set(
         unique_id: JobUniqueId,
         schedule_data: ScheduleModel,
         *,
-        timeout: timedelta | None,  # noqa: ASYNC109
+        expire: timedelta | None,
     ) -> None:
+        """
+        timeout -- if None means to keep the existing ttl if one was set previously
+        """
+
         key = self._get_key(unique_id)
 
-        if timeout is None:
+        if expire is None:
             expire_seconds = None
             keep_ttl = True
         else:
-            expire_seconds = int(timeout.total_seconds())
+            expire_seconds = int(expire.total_seconds())
             keep_ttl = False
 
-        await self._redis_sdk.redis.set(
+        await self.redis_sdk.redis.set(
             key,
             schedule_data.model_dump_json().encode(),
             ex=expire_seconds,
@@ -73,24 +77,24 @@ async def set(
 
     async def remove(self, unique_id: JobUniqueId) -> None:
         key = self._get_key(unique_id)
-        await self._redis_sdk.redis.delete(key)
+        await self.redis_sdk.redis.delete(key)
 
     async def get_existing(self, unique_id: JobUniqueId) -> ScheduleModel:
         data = await self.get(unique_id)
         if data is None:
             raise UnexpectedJobNotFoundError(unique_id=unique_id)
         return data
 
-    async def update_timeout(
-        self, unique_id: JobUniqueId, *, timeout: timedelta  # noqa: ASYNC109
+    async def update_entry_expiry(
+        self, unique_id: JobUniqueId, *, expire: timedelta
     ) -> None:
         key = self._get_key(unique_id)
-        await self._redis_sdk.redis.expire(key, time=int(timeout.total_seconds()))
+        await self.redis_sdk.redis.expire(key, time=int(expire.total_seconds()))
 
     @asynccontextmanager
     async def auto_save_get(
         self, unique_id: JobUniqueId
     ) -> AsyncIterator[ScheduleModel]:
         data = await self.get_existing(unique_id)
         yield data
-        await self.set(unique_id, data, timeout=None)
+        await self.set(unique_id, data, expire=None)

packages/service-library/tests/long_running_interfaces/test__redis.py

@@ -27,6 +27,8 @@ async def client_store_interface(
     client = ClientStoreInterface(redis_service, long_running_namespace)
     await client.setup()
 
+    await client.redis_sdk.redis.flushdb()
+
     yield client
 
     await client.teardown()
@@ -45,7 +47,7 @@ async def test_get_set_delete(
 ):
     assert await client_store_interface.get(unique_id) is None
 
-    await client_store_interface.set(unique_id, schedule_model, timeout=job_timeout)
+    await client_store_interface.set(unique_id, schedule_model, expire=job_timeout)
     assert await client_store_interface.get(unique_id) == schedule_model
 
     await client_store_interface.remove(unique_id)
@@ -62,7 +64,7 @@ async def test_auto_save_get(
     schedule_model: ScheduleModel,
     job_timeout: timedelta,
 ):
-    await client_store_interface.set(unique_id, schedule_model, timeout=job_timeout)
+    await client_store_interface.set(unique_id, schedule_model, expire=job_timeout)
 
     assert await client_store_interface.get(unique_id) == schedule_model
     async with client_store_interface.auto_save_get(unique_id) as auto_saved:
@@ -71,26 +73,45 @@ async def test_auto_save_get(
     assert await client_store_interface.get(unique_id) == auto_saved
 
 
-async def test_expired_key(
+async def test_key_does_not_expire(
     client_store_interface: ClientStoreInterface,
     unique_id: JobUniqueId,
     schedule_model: ScheduleModel,
     job_timeout: timedelta,
 ):
-    await client_store_interface.set(unique_id, schedule_model, timeout=job_timeout)
+    # check key does not expire
+    await client_store_interface.set(unique_id, schedule_model, expire=None)
+    assert await client_store_interface.get(unique_id) is not None
+    assert await client_store_interface.get_existing(unique_id)
+
+    # wait a bit and key shoult still be there
+    await asyncio.sleep(job_timeout.total_seconds())
+
+    assert await client_store_interface.get(unique_id) is not None
+    assert await client_store_interface.get_existing(unique_id)
 
+
+async def test_key_actually_expires(
+    client_store_interface: ClientStoreInterface,
+    unique_id: JobUniqueId,
+    schedule_model: ScheduleModel,
+    job_timeout: timedelta,
+):
+    await client_store_interface.set(unique_id, schedule_model, expire=job_timeout)
     assert await client_store_interface.get(unique_id) is not None
     assert await client_store_interface.get_existing(unique_id)
 
+    # check that key actially expires
     await asyncio.sleep(job_timeout.total_seconds())
 
     assert await client_store_interface.get(unique_id) is None
     with pytest.raises(UnexpectedJobNotFoundError):
         await client_store_interface.get_existing(unique_id)
 
 
-async def test_update_timeout_not_existing(
-    client_store_interface: ClientStoreInterface,
-    job_timeout: timedelta,
+async def test_update_entry_expiry_not_existing(
+    client_store_interface: ClientStoreInterface, job_timeout: timedelta
 ):
-    await client_store_interface.update_timeout("missing", timeout=job_timeout)
+    await client_store_interface.update_entry_expiry(
+        "missing_asdads", expire=job_timeout
+    )