Address code review comments

Author: 1st1

asyncpg/connection.py

@@ -724,7 +724,9 @@ async def connect(dsn=None, *,
                                      Pass ``0`` to disable the cache.
 
     :param int max_cached_statement_lifetime:
-        number of seconds a prepared statement can stay in the cache.
+        the maximum time in seconds a prepared statement will stay
+        in the cache.  Pass ``0`` to allow statements be cached
+        indefinitely.
 
     :param float command_timeout: the default timeout for operations on
                           this connection (the default is no timeout).
@@ -823,9 +825,9 @@ def __init__(self, *, loop, max_size, on_remove, max_lifetime):
 
         # We use an OrderedDict for LRU implementation.  Operations:
         #
-        #  * We use a simple `__setitem__` to push a new entry:
+        # * We use a simple `__setitem__` to push a new entry:
         #       `entries[key] = new_entry`
-        #    That will push `new_entry` to the *end* of the entries dict.
+        #   That will push `new_entry` to the *end* of the entries dict.
         #
         # * When we have a cache hit, we call
         #       `entries.move_to_end(key, last=True)`
@@ -847,14 +849,18 @@ def get_max_size(self):
         return self._max_size
 
     def set_max_size(self, new_size):
+        assert new_size >= 0
         self._max_size = new_size
         self._maybe_cleanup()
 
     def get_max_lifetime(self):
         return self._max_lifetime
 
     def set_max_lifetime(self, new_lifetime):
+        assert new_lifetime >= 0
         self._max_lifetime = new_lifetime
+        for entry in self._entries.values():
+            self._set_entry_timeout(entry)
 
     def get(self, query, *, promote=True):
         if not self._max_size:
@@ -890,13 +896,19 @@ def iter_statements(self):
         return (e._statement for e in self._entries.values())
 
     def clear(self):
+        for entry in self._entries.values():
+            self._clear_entry_callback(entry)
         self._entries.clear()
 
-    def _new_entry(self, query, statement):
-        entry = _StatementCacheEntry(self, query, statement)
+    def _set_entry_timeout(self, entry):
+        self._clear_entry_callback(entry)
         if self._max_lifetime:
             entry._cleanup_cb = self._loop.call_later(
                 self._max_lifetime, self._on_entry_expired, entry)
+
+    def _new_entry(self, query, statement):
+        entry = _StatementCacheEntry(self, query, statement)
+        self._set_entry_timeout(entry)
         return entry
 
     def _on_entry_expired(self, entry):

tests/test_prepare.py

@@ -462,7 +462,7 @@ async def check_simple():
         # operation.
         await check_simple()
 
-    async def test_prepare_24_max_use_count(self):
+    async def test_prepare_24_max_lifetime(self):
         cache = self.con._stmt_cache
         cache.set_max_lifetime(1)