Clean-up and polish

Author: robsdedude

.gitattributes

@@ -1,5 +1,5 @@
 # configure github not to display generated files
 /src/neo4j/_sync/** linguist-generated=true
-/tests/unit/sync_/** linguist-generated=true
-/tests/integration/sync_/** linguist-generated=true
+/tests/unit/sync/** linguist-generated=true
+/tests/integration/sync/** linguist-generated=true
 /testkitbackend/_sync/** linguist-generated=true

docs/source/api.rst

@@ -165,7 +165,7 @@ Closing a driver will immediately shut down all connections in the pool.
 .. autoclass:: neo4j.Driver()
     :members: session, execute_query_bookmark_manager, encrypted, close,
               verify_connectivity, get_server_info, verify_authentication,
-              supports_session_auth, supports_multi_db, force_home_database_resolution
+              supports_session_auth, supports_multi_db
 
     .. method:: execute_query(query, parameters_=None,routing_=neo4j.RoutingControl.WRITE, database_=None, impersonated_user_=None, bookmark_manager_=self.execute_query_bookmark_manager, auth_=None, result_transformer_=Result.to_eager_result, **kwargs)
 

src/neo4j/_async/home_db_cache.py

@@ -60,6 +60,11 @@ def __init__(
                 f"got {max_size}"
             )
         self._max_size = max_size
+        self._truncate_size = (
+            min(max_size, int(0.01 * max_size * math.log(max_size)))
+            if max_size is not None
+            else None
+        )
 
     def compute_key(
         self,
@@ -106,7 +111,9 @@ def _clean(self, now: float | None = None) -> None:
         now = monotonic() if now is None else now
         if now - self._oldest_entry > self._ttl:
             self._cache = {
-                k: v for k, v in self._cache.items() if now - v[0] < self._ttl
+                k: v
+                for k, v in self._cache.items()
+                if now - v[0] < self._ttl * 0.9
             }
             self._oldest_entry = min(
                 (v[0] for v in self._cache.values()), default=now
@@ -117,7 +124,7 @@ def _clean(self, now: float | None = None) -> None:
                     self._cache.items(),
                     key=lambda item: item[1][0],
                     reverse=True,
-                )[: int(self._max_size * 0.9)]
+                )[: self._truncate_size]
             )
 
     def __len__(self) -> int:

src/neo4j/_async/io/_pool.py

@@ -105,13 +105,13 @@ def add_connection(self, connection):
     def remove_connection(self, connection):
         if self.feature_check(connection):
             if self.with_feature == 0:
-                raise ValueError(
+                raise RuntimeError(
                     "No connections to be removed from feature tracker"
                 )
             self.with_feature -= 1
         else:
             if self.without_feature == 0:
-                raise ValueError(
+                raise RuntimeError(
                     "No connections to be removed from feature tracker"
                 )
             self.without_feature -= 1
@@ -143,7 +143,8 @@ def is_direct_pool(self) -> bool: ...
 
     @property
     def ssr_enabled(self) -> bool:
-        return self._ssr_feature_tracker.has_feature
+        with self.lock:
+            return self._ssr_feature_tracker.has_feature
 
     async def __aenter__(self):
         return self
@@ -601,8 +602,8 @@ async def close(self):
                     for address in list(self.connections)
                     for connection in self.connections.pop(address, ())
                 ]
-            for connection in connections:
-                self._ssr_feature_tracker.remove_connection(connection)
+                for connection in connections:
+                    self._ssr_feature_tracker.remove_connection(connection)
             await self._close_connections(connections)
         except TypeError:
             pass
@@ -1012,7 +1013,7 @@ async def update_routing_table(
             log.error("Unable to retrieve routing information")
             raise ServiceUnavailable("Unable to retrieve routing information")
 
-    async def update_connection_pool(self, *, database):
+    async def update_connection_pool(self):
         async with self.refresh_lock:
             routing_tables = list(self.routing_tables.values())
 
@@ -1077,12 +1078,14 @@ async def ensure_routing_table_is_fresh(
                 )
                 return False
 
+            database_request = database.name if not database.guessed else None
+
             async def wrapped_database_callback(database: str | None) -> None:
                 await AsyncUtil.callback(database_callback, database)
-                await self.update_connection_pool(database=database)
+                await self.update_connection_pool()
 
             await self.update_routing_table(
-                database=database.name if not database.guessed else None,
+                database=database_request,
                 imp_user=imp_user,
                 bookmarks=bookmarks,
                 auth=auth,

src/neo4j/_async/work/workspace.py

@@ -104,14 +104,15 @@ async def __aenter__(self) -> AsyncWorkspace:
     async def __aexit__(self, exc_type, exc_value, traceback):
         await self.close()
 
-    def _make_db_resolution_callback(self) -> t.Callable[[str], None] | None:
+    def _make_db_resolution_callback(
+        self,
+    ) -> t.Callable[[str | None], None] | None:
         if self._pinned_database:
             return None
 
         def _database_callback(database: str | None) -> None:
-            if not self._pinned_database:
-                self._set_pinned_database(database)
-            if self._last_cache_key is None:
+            self._set_pinned_database(database)
+            if self._last_cache_key is None or database is None:
                 return
             db_cache: AsyncHomeDbCache = self._pool.home_db_cache
             db_cache.set(self._last_cache_key, database)
@@ -206,7 +207,7 @@ async def _connect(self, access_mode, auth=None, **acquire_kwargs) -> None:
                 not self._pool.ssr_enabled or not self._connection.ssr_enabled
             )
         ):
-            # race condition: in the meantime, the pool added a connection,
+            # race condition: in the meantime the pool added a connection
             # which does not support SSR.
             # => we need to fall back to explicit home database resolution
             log.debug(

src/neo4j/_sync/home_db_cache.py

@@ -14,6 +14,8 @@
 # limitations under the License.
 
 
+from functools import wraps as _wraps
+
 from .mark_decorator import (
     AsyncTestDecorators,
     mark_async_test,
@@ -27,4 +29,15 @@
     "TestDecorators",
     "mark_async_test",
     "mark_sync_test",
+    "wrap_async",
 ]
+
+
+def wrap_async(func):
+    @_wraps(func)
+    async def wrapper(*args, **kwargs):  # noqa: RUF029
+        # [noqa] the hole point of this wrapper is to turn a sync function into
+        # an async one for testing purposes
+        return func(*args, **kwargs)
+
+    return wrapper

src/neo4j/_sync/io/_pool.py

@@ -569,3 +569,25 @@ def on_success(metadata):
     await connection.fetch_all()
 
     assert received_metadata == sent_metadata
+
+
+@pytest.mark.parametrize("ssr_hint", (True, False, None))
+@mark_async_test
+async def test_ssr_enabled(ssr_hint, fake_socket_pair):
+    address = neo4j.Address(("127.0.0.1", 7687))
+    sockets = fake_socket_pair(
+        address,
+        packer_cls=AsyncBolt3.PACKER_CLS,
+        unpacker_cls=AsyncBolt3.UNPACKER_CLS,
+    )
+    meta = {"server": "Neo4j/4.3.4"}
+    if ssr_hint is not None:
+        meta["hints"] = {"ssr.enabled": ssr_hint}
+    await sockets.server.send_message(b"\x70", meta)
+    await sockets.server.send_message(b"\x70", {})
+    connection = AsyncBolt3(
+        address, sockets.client, AsyncPoolConfig.max_connection_lifetime
+    )
+    assert connection.ssr_enabled is False
+    await connection.hello()
+    assert connection.ssr_enabled is False