Fix error during_commit tracking in auto-commit transactions (#49)

After `RUN` has successfully been sent, the server might commit the transaction
at any time (but no later than when the result stream has been fully consumed).

Therefore, any disconnect (i/o error) that occurs after an auto-commit's `RUN`
has been sent must be considered to have happened `during_commit`. This most
notably affects `Neo4jError::is_retryable`.

Author: robsdedude

CHANGELOG.md

@@ -30,6 +30,7 @@
  - Fix `connection_acquisition_timeout` config not being applied to limit fetching of routing tables.
  - Fix the driver handling cluster network partitioning poorly by accepting the first routing table regardless whether
    it contains a writer or not.
+ - Fix auto-commit such that any connectivity error after sending the `RUN` message is considered to have happened `during_commit`.
 
 
 ## 0.2.0

neo4j/src/driver/record_stream.rs

@@ -96,17 +96,13 @@ impl<'driver> RecordStream<'driver> {
         let mut res = self.connection.borrow_mut().run(parameters, callbacks);
         if self.auto_commit {
             res = res.and_then(|_| self.connection.borrow_mut().write_all(None));
-            res = match res.and_then(|_| self.pull(true)) {
-                Err(e) => {
-                    let mut listener = self.listener.borrow_mut();
-                    listener.state = RecordListenerState::Done;
-                    return Err(e);
-                }
-                Ok(res) => Ok(res),
+            if let Err(e) = res {
+                let mut listener = self.listener.borrow_mut();
+                listener.state = RecordListenerState::Done;
+                return Err(e);
             }
-        } else {
-            res = self.pull(true);
         }
+        res = res.and_then(|_| self.pull(true));
 
         if let Err(e) = res.and_then(|_| {
             // read until only response(s) to PULL is/are left

neo4j/src/driver/session/retry.rs

@@ -121,7 +121,7 @@ pub trait RetryPolicy {
 ///
 /// The policy will return a [`RetryError::Neo4jError`] if the work function returns a
 /// non-retryable [`Neo4jError`].
-/// It will return a [`RetryError::Timeout`] the policy would start another attempt, but the time
+/// It will return a [`RetryError::Timeout`] if the policy would start another attempt, but the time
 /// since the end of the first attempt exceeds the maximum retry time.
 #[derive(Debug, Clone, Copy)]
 pub struct ExponentialBackoff {