Adjust error thrown

Author: bigmontz

packages/core/src/transaction.ts

@@ -291,12 +291,15 @@ class Transaction {
     }
   }
 
-  _onErrorCallback (error: Error): Promise<Connection | null> {
+  _onErrorCallback (): Promise<Connection | null> {
     // error will be "acknowledged" by sending a RESET message
     // database will then forget about this transaction and cleanup all corresponding resources
     // it is thus safe to move this transaction to a FAILED state and disallow any further interactions with it
     this._state = _states.FAILED
     this._onClose()
+    const error = newError(
+      'Cannot interact with this result, because transaction has been rolled back either because of an error.'
+    )
     this._results.forEach(result => {
       if (result.isOpen()) {
         // @ts-expect-error

packages/core/test/transaction.test.ts

@@ -217,7 +217,7 @@ testTx('TransactionPromise', newTransactionPromise, () => {
 
           try {
             await tx.commit()
-            fail('shoud not succeed')
+            fail('should not succeed')
           } catch (e) {
             expect(e).toEqual(newError(
               'Cannot commit this transaction, because it has been rolled back either because of an error or explicit termination.'
@@ -397,6 +397,9 @@ function testTx<T extends Transaction> (transactionName: string, newTransaction:
       it('should cascade errors in a result to other open results', async () => {
         const connection = newFakeConnection()
         const expectedError = newError('Something right is not wrong, wut?')
+        const expectedTerminationError = newError(
+          'Cannot interact with this result, because transaction has been rolled back either because of an error.'
+        )
         const tx = newTransaction({
           connection,
           fetchSize: 1000,
@@ -430,8 +433,8 @@ function testTx<T extends Transaction> (transactionName: string, newTransaction:
         const brokenResult = tx.run('should error')
 
         await expect(brokenResult).rejects.toThrowError(expectedError)
-        await expect(nonConsumedResult).rejects.toThrowError(expectedError)
-        expect(observers[0].error).toEqual(expectedError)
+        await expect(nonConsumedResult).rejects.toThrowError(expectedTerminationError)
+        expect(observers[0].error).toEqual(expectedTerminationError)
         expect(observers[1].error).not.toBeDefined()
         expect(observers[2].error).toEqual(expectedError)
       })

packages/core/test/utils/result-stream-observer.mock.ts

@@ -95,6 +95,11 @@ export default class ResultStreamObserverMock implements observer.ResultStreamOb
   }
 
   onError (error: Error): void {
+    if (this._error != null) {
+      // The implementation of stream observer
+      // ignores errors happens after an error occurs.
+      return
+    }
     this._error = error
     if (this._beforeError != null) {
       this._beforeError(error)

packages/neo4j-driver-deno/lib/core/transaction.ts

@@ -291,15 +291,18 @@ class Transaction {
     }
   }
 
-  _onErrorCallback (error: Error): Promise<Connection | null> {
+  _onErrorCallback (): Promise<Connection | null> {
     // error will be "acknowledged" by sending a RESET message
     // database will then forget about this transaction and cleanup all corresponding resources
     // it is thus safe to move this transaction to a FAILED state and disallow any further interactions with it
     this._state = _states.FAILED
     this._onClose()
+    const error = newError(
+      'Cannot interact with this result, because transaction has been rolled back either because of an error.'
+    )
     this._results.forEach(result => {
       if (result.isOpen()) {
-        // @ts-expect-error 
+        // @ts-expect-error
         result._streamObserverPromise
           .then(resultStreamObserver => resultStreamObserver.onError(error))
           // Nothing to do since we don't have a observer to notify the error