Acquire RT without impersonated user if possible

This is an optimization saving a few bytes over the wire.
When there is an explicit database configured for a session, there is no need
to send the impersonated user along with the `ROUTE` request. The only
difference this would make is that insufficient permissions would be noticed
when fetching the RT instead of when performing any actual action on the
session. Since routing is part of the global driver/pool operations and not
coupled to sessions, doing it this way seems like the logical conclusion.

Author: robsdedude

neo4j/io/__init__.py

@@ -711,13 +711,12 @@ def time_remaining():
                                       "within {!r}s".format(timeout))
 
     def acquire(self, access_mode=None, timeout=None, database=None,
-                imp_user=None, bookmarks=None):
+                bookmarks=None):
         """ Acquire a connection to a server that can satisfy a set of parameters.
 
         :param access_mode:
         :param timeout:
         :param database:
-        :param imp_user:
         :param bookmarks:
         """
 
@@ -1152,7 +1151,7 @@ def ensure_routing_table_is_fresh(self, *, access_mode, database, imp_user,
 
             return True
 
-    def _select_address(self, *, access_mode, database, imp_user, bookmarks):
+    def _select_address(self, *, access_mode, database):
         from neo4j.api import READ_ACCESS
         """ Selects the address with the fewest in-use connections.
         """
@@ -1178,29 +1177,29 @@ def _select_address(self, *, access_mode, database, imp_user, bookmarks):
         return choice(addresses_by_usage[min(addresses_by_usage)])
 
     def acquire(self, access_mode=None, timeout=None, database=None,
-                imp_user=None, bookmarks=None):
+                bookmarks=None):
         if access_mode not in (WRITE_ACCESS, READ_ACCESS):
             raise ClientError("Non valid 'access_mode'; {}".format(access_mode))
         if not timeout:
-            raise ClientError("'timeout' must be a float larger than 0; {}".format(timeout))
+            raise ClientError("'timeout' must be a float larger than 0; {}"
+                              .format(timeout))
 
         from neo4j.api import check_access_mode
         access_mode = check_access_mode(access_mode)
         with self.refresh_lock:
             log.debug("[#0000]  C: <ROUTING TABLE ENSURE FRESH> %r",
                       self.routing_tables)
             self.ensure_routing_table_is_fresh(
-                access_mode=access_mode, database=database, imp_user=imp_user,
+                access_mode=access_mode, database=database, imp_user=None,
                 bookmarks=bookmarks
             )
 
         while True:
             try:
-                # Get an address for a connection that have the fewest in-use connections.
-                address = self._select_address(
-                    access_mode=access_mode, database=database,
-                    imp_user=imp_user, bookmarks=bookmarks
-                )
+                # Get an address for a connection that have the fewest in-use
+                # connections.
+                address = self._select_address(access_mode=access_mode,
+                                               database=database)
             except (ReadServiceUnavailable, WriteServiceUnavailable) as err:
                 raise SessionExpired("Failed to obtain connection towards '%s' server." % access_mode) from err
             try:

neo4j/work/simple.py

@@ -144,7 +144,6 @@ def _connect(self, access_mode):
             access_mode=access_mode,
             timeout=self._config.connection_acquisition_timeout,
             database=self._config.database,
-            imp_user=self._config.impersonated_user,
             bookmarks=self._bookmarks
         )
 

tests/unit/io/test_direct.py

@@ -104,8 +104,7 @@ def opener(addr, timeout):
         super().__init__(opener, self.pool_config, self.workspace_config)
         self.address = address
 
-    def acquire(self, access_mode=None, timeout=None, database=None,
-                imp_user=None):
+    def acquire(self, access_mode=None, timeout=None, database=None):
         return self._acquire(self.address, timeout)
 
 

tests/unit/test_driver.py

@@ -137,7 +137,6 @@ def test_driver_opens_write_session_by_default(uri, mocker):
             access_mode=WRITE_ACCESS,
             timeout=mocker.ANY,
             database=mocker.ANY,
-            imp_user=mocker.ANY,
             bookmarks=mocker.ANY
         )
         tx_begin_mock.assert_called_once_with(