Tidy up ttls (#215)

* Tidy up ttls

* lint

* Remove s3 tests

* Fix CI

* Fix coverage

* Fix coverage

* Change to update_metadata in httpcore pool

* Fix type

* changelog

* Remove read call from _create_hishel_response

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## Unrelesed
+
+- Prevent cache hits from resetting the ttl. (#215)
+
 ## 0.0.25 (26th March, 2024)
 
 - Add `force_cache` property to the controller, allowing RFC9111 rules to be completely disabled. (#204)

hishel/_async/_pool.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime
 import types
 import typing as tp
@@ -85,6 +87,7 @@ async def handle_async_request(self, request: Request) -> Response:
             # Try using the stored response if it was discovered.
 
             stored_response, stored_request, metadata = stored_data
+            stored_response.read()
 
             res = self._controller.construct_response_from_cache(
                 request=request,
@@ -94,17 +97,9 @@ async def handle_async_request(self, request: Request) -> Response:
 
             if isinstance(res, Response):
                 # Simply use the response if the controller determines it is ready for use.
-                metadata["number_of_uses"] += 1
-                stored_response.read()
-                await self._storage.store(
-                    key=key,
-                    request=request,
-                    response=stored_response,
-                    metadata=metadata,
+                return await self._create_hishel_response(
+                    key=key, response=stored_response, request=request, metadata=metadata, cached=True
                 )
-                res.extensions["from_cache"] = True  # type: ignore[index]
-                res.extensions["cache_metadata"] = metadata  # type: ignore[index]
-                return res
 
             if request_cache_control.only_if_cached:
                 return generate_504()
@@ -116,33 +111,47 @@ async def handle_async_request(self, request: Request) -> Response:
                     response = await self._pool.handle_async_request(res)
                 except ConnectError:
                     if self._controller._allow_stale and allowed_stale(response=stored_response):
-                        stored_response.extensions["from_cache"] = True  # type: ignore[index]
-                        stored_response.extensions["cache_metadata"] = metadata  # type: ignore[index]
-                        return stored_response
+                        return await self._create_hishel_response(
+                            key=key, response=stored_response, request=request, metadata=metadata, cached=True
+                        )
                     raise  # pragma: no cover
                 # Merge headers with the stale response.
                 full_response = self._controller.handle_validation_response(
                     old_response=stored_response, new_response=response
                 )
 
                 await full_response.aread()
-                metadata["number_of_uses"] += response.status == 304
-                await self._storage.store(key, response=full_response, request=request, metadata=metadata)
-                full_response.extensions["from_cache"] = response.status == 304  # type: ignore[index]
-                if full_response.extensions["from_cache"]:
-                    full_response.extensions["cache_metadata"] = metadata  # type: ignore[index]
-                return full_response
+                return await self._create_hishel_response(
+                    key=key, response=full_response, request=request, metadata=metadata, cached=response.status == 304
+                )
 
         response = await self._pool.handle_async_request(request)
+        await response.aread()
 
         if self._controller.is_cachable(request=request, response=response):
-            await response.aread()
             metadata = Metadata(
                 cache_key=key, created_at=datetime.datetime.now(datetime.timezone.utc), number_of_uses=0
             )
             await self._storage.store(key, response=response, request=request, metadata=metadata)
 
-        response.extensions["from_cache"] = False  # type: ignore[index]
+        return await self._create_hishel_response(key=key, response=response, request=request, cached=False)
+
+    async def _create_hishel_response(
+        self,
+        key: str,
+        response: Response,
+        request: Request,
+        cached: bool,
+        metadata: Metadata | None = None,
+    ) -> Response:
+        if cached:
+            assert metadata
+            metadata["number_of_uses"] += 1
+            await self._storage.update_metadata(key=key, request=request, response=response, metadata=metadata)
+            response.extensions["from_cache"] = True  # type: ignore[index]
+            response.extensions["cache_metadata"] = metadata  # type: ignore[index]
+        else:
+            response.extensions["from_cache"] = False  # type: ignore[index]
         return response
 
     async def aclose(self) -> None: