Add tests for transaction lifetime

E.g., what happens when you commit, a closed (committed, rolled back, ...)
transaction or when you try to manage a transaction inside a transaction
function.

Author: robsdedude

nutkit/frontend/__init__.py

@@ -1 +1,2 @@
 from .driver import Driver
+from .exceptions import ApplicationCodeError

nutkit/frontend/exceptions.py

@@ -0,0 +1,2 @@
+class ApplicationCodeError(Exception):
+    pass

nutkit/frontend/session.py

@@ -1,12 +1,9 @@
 from .. import protocol
+from .exceptions import ApplicationCodeError
 from .result import Result
 from .transaction import Transaction
 
 
-class ApplicationCodeError(Exception):
-    pass
-
-
 class Session:
     def __init__(self, driver, session):
         self._driver = driver

tests/neo4j/test_tx_func_run.py

@@ -1,4 +1,4 @@
-from nutkit.frontend.session import ApplicationCodeError
+from nutkit.frontend import ApplicationCodeError
 import nutkit.protocol as types
 from tests.neo4j.shared import (
     get_driver,

tests/stub/tx_lifetime/__init__.py

@@ -0,0 +1,32 @@
+!: BOLT 4.4
+
+A: HELLO {"{}": "*"}
+*: RESET
+C: BEGIN {"{}": "*"}
+S: SUCCESS {}
+C: RUN {"U": "*"} {"{}": "*"} {"{}": "*"}
+S: SUCCESS {"fields": ["n"]}
+{*
+    C: PULL {"n": {"Z": "*"}, "[qid]": -1}
+    S: RECORD [1]
+       RECORD [2]
+       SUCCESS {"has_more": true}
+*}
+{{
+    C: DISCARD {"n": -1, "[qid]": -1}
+    S: SUCCESS {"type": "r"}
+    {?
+        {{
+            C: ROLLBACK
+        ----
+            C: COMMIT
+        ----
+            C: RESET
+        }}
+        S: SUCCESS {}
+    ?}
+----
+    A: RESET
+}}
+*: RESET
+?: GOODBYE

tests/stub/tx_lifetime/scripts/v4x4/tx_inf_results_until_end.script

@@ -0,0 +1,112 @@
+from contextlib import contextmanager
+
+from nutkit.frontend import Driver
+import nutkit.protocol as types
+from tests.shared import (
+    get_driver_name,
+    TestkitTestCase,
+)
+from tests.stub.shared import StubServer
+
+
+class TestTxLifetime(TestkitTestCase):
+    def setUp(self):
+        super().setUp()
+        self._server = StubServer(9000)
+
+    def tearDown(self):
+        # If test raised an exception this will make sure that the stub server
+        # is killed and it's output is dumped for analysis.
+        self._server.reset()
+        super().tearDown()
+
+    @contextmanager
+    def _start_session(self, script):
+        uri = "bolt://%s" % self._server.address
+        driver = Driver(self._backend, uri,
+                        types.AuthorizationToken("basic", principal="",
+                                                 credentials=""))
+        self._server.start(path=self.script_path("v4x4", script))
+        session = driver.session("r", fetch_size=2)
+        try:
+            yield session
+        finally:
+            session.close()
+            driver.close()
+
+    def _asserts_tx_closed_error(self, exc):
+        driver = get_driver_name()
+        assert isinstance(exc, types.DriverError)
+        if driver in ["python"]:
+            self.assertEqual(exc.errorType,
+                             "<class 'neo4j.exceptions.TransactionError'>")
+            self.assertIn("closed", exc.msg.lower())
+        elif driver in ["javascript", "go", "dotnet"]:
+            self.assertIn("transaction", exc.msg.lower())
+        elif driver in ["java"]:
+            self.assertEqual(exc.errorType,
+                             "org.neo4j.driver.exceptions.ClientException")
+        else:
+            self.fail("no error mapping is defined for %s driver" % driver)
+
+    def _asserts_tx_managed_error(self, exc):
+        driver = get_driver_name()
+        if driver in ["python"]:
+            self.assertEqual(exc.errorType, "<class 'AttributeError'>")
+            self.assertIn("managed", exc.msg.lower())
+        else:
+            self.fail("no error mapping is defined for %s driver" % driver)
+
+    def test_raises_tx_closed_exec(self):
+        def test(first_action_, second_action_, tx_func_):
+            def work(tx_):
+                res_ = tx_.run("Query")
+                res_.consume()
+                with self.assertRaises(types.DriverError) as exc_:
+                    getattr(tx_, first_action_)()
+                self._asserts_tx_managed_error(exc_.exception)
+                raise exc_.exception
+
+            exc = None
+            script = "tx_inf_results_until_end.script"
+            with self._start_session(script) as session:
+                if tx_func_:
+                    with self.assertRaises(types.DriverError):
+                        session.read_transaction(work)
+                else:
+                    tx = session.begin_transaction()
+                    res = tx.run("Query")
+                    res.consume()
+                    getattr(tx, first_action_)()
+                    if second_action_ == "close":
+                        getattr(tx, second_action_)()
+                    elif second_action_ == "run":
+                        with self.assertRaises(types.DriverError) as exc:
+                            tx.run("Query").consume()
+                    else:
+                        with self.assertRaises(types.DriverError) as exc:
+                            getattr(tx, second_action_)()
+            self._server.done()
+            self.assertEqual(
+                self._server.count_requests("ROLLBACK"),
+                int(tx_func_ or first_action_ in ["rollback", "close"])
+            )
+            self.assertEqual(
+                self._server.count_requests("COMMIT"),
+                int(not tx_func_ and first_action_ == "commit")
+            )
+            if exc is not None:
+                self._asserts_tx_closed_error(exc.exception)
+
+        for first_action in ("commit", "rollback", "close"):
+            for tx_func in (True, False):
+                if tx_func:
+                    second_actions = None,
+                else:
+                    second_actions = "commit", "rollback", "close", "run"
+                for second_action in second_actions:
+                    with self.subTest(first_action=first_action,
+                                      second_action=second_action,
+                                      tx_func=tx_func):
+                        test(first_action, second_action, tx_func)
+                    self._server.reset()