add another failing test

src/Illuminate/Database/DatabaseTransactionsManager.php

@@ -46,23 +46,25 @@ public function begin($connection, $level)
     }
 
     /**
-     * Rollback the active database transaction.
+     * Move relevant pending transactions to a committed state.
      *
      * @param  string  $connection
-     * @param  int  $newTransactionLevel
+     * @param  int  $levelBeingCommitted
      * @return void
      */
-    public function rollback($connection, $newTransactionLevel)
+    public function stageTransactions($connection, $levelBeingCommitted)
     {
-        if ($newTransactionLevel === 0) {
-            $this->pendingTransactions = new Collection;
-            $this->committedTransactions = new Collection;
-        } else {
-            $this->pendingTransactions = $this->pendingTransactions->reject(
-                fn ($transaction) => $transaction->connection == $connection &&
-                                     $transaction->level > $newTransactionLevel
-            )->values();
-        }
+        $this->committedTransactions = $this->committedTransactions->merge(
+            $this->pendingTransactions->filter(
+                fn ($transaction) => $transaction->connection === $connection &&
+                                     $transaction->level >= $levelBeingCommitted
+            )
+        );
+
+        $this->pendingTransactions = $this->pendingTransactions->reject(
+            fn ($transaction) => $transaction->connection === $connection &&
+                                 $transaction->level >= $levelBeingCommitted
+        );
     }
 
     /**
@@ -83,40 +85,38 @@ public function commit($connection)
     }
 
     /**
-     * Register a transaction callback.
+     * Rollback the active database transaction.
      *
-     * @param  callable  $callback
+     * @param  string  $connection
+     * @param  int  $newTransactionLevel
      * @return void
      */
-    public function addCallback($callback)
+    public function rollback($connection, $newTransactionLevel)
     {
-        if ($current = $this->callbackApplicableTransactions()->last()) {
-            return $current->addCallback($callback);
+        if ($newTransactionLevel === 0) {
+            $this->pendingTransactions = new Collection;
+            $this->committedTransactions = new Collection;
+        } else {
+            $this->pendingTransactions = $this->pendingTransactions->reject(
+                fn ($transaction) => $transaction->connection == $connection &&
+                                     $transaction->level > $newTransactionLevel
+            )->values();
         }
-
-        $callback();
     }
 
     /**
-     * Move relevant pending transactions to a committed state.
+     * Register a transaction callback.
      *
-     * @param  string  $connection
-     * @param  int  $levelBeingCommitted
+     * @param  callable  $callback
      * @return void
      */
-    public function stageTransactions($connection, $levelBeingCommitted)
+    public function addCallback($callback)
     {
-        $this->committedTransactions = $this->committedTransactions->merge(
-            $this->pendingTransactions->filter(
-                fn ($transaction) => $transaction->connection === $connection &&
-                                     $transaction->level >= $levelBeingCommitted
-            )
-        );
+        if ($current = $this->callbackApplicableTransactions()->last()) {
+            return $current->addCallback($callback);
+        }
 
-        $this->pendingTransactions = $this->pendingTransactions->reject(
-            fn ($transaction) => $transaction->connection === $connection &&
-                                 $transaction->level >= $levelBeingCommitted
-        );
+        $callback();
     }
 
     /**

tests/Integration/Events/ShouldDispatchAfterCommitEventTest.php

@@ -170,6 +170,51 @@ public function testChildEventsAreNotDispatchedIfParentTransactionFails()
         // Should not have ran because parent transaction failed...
         $this->assertFalse(ShouldDispatchAfterCommitTestEvent::$ran);
     }
+
+public function testItHandlesNestedTransactionsWhereTheSecondOneFails()
+    {
+        Event::listen(ShouldDispatchAfterCommitTestEvent::class, ShouldDispatchAfterCommitListener::class);
+        Event::listen(AnotherShouldDispatchAfterCommitTestEvent::class, AnotherShouldDispatchAfterCommitListener::class);
+
+        DB::transaction(function () {
+            DB::transaction(function () {
+                Event::dispatch(new ShouldDispatchAfterCommitTestEvent());
+            });
+
+            try {
+                DB::transaction(function () {
+                    // This event should not be dispatched since the transaction is going to fail.
+                    Event::dispatch(new AnotherShouldDispatchAfterCommitTestEvent);
+                    throw new \Exception;
+                });
+            } catch (\Exception $e) {
+            }
+        });
+
+        $this->assertTrue(ShouldDispatchAfterCommitTestEvent::$ran);
+        $this->assertFalse(AnotherShouldDispatchAfterCommitTestEvent::$ran);
+    }
+
+    public function testItHandlesDeeplyNestedTransactions()
+    {
+        Event::listen(ShouldDispatchAfterCommitTestEvent::class, ShouldDispatchAfterCommitListener::class);
+
+            DB::transaction(function () {
+                try {
+                    DB::transaction(function () {
+                        DB::transaction(function () {
+                            Event::dispatch(new ShouldDispatchAfterCommitTestEvent());
+                        });
+
+                        throw new \Exception;
+                    });
+                } catch (\Exception $e) {
+                    //
+                }
+            });
+
+        $this->assertFalse(ShouldDispatchAfterCommitTestEvent::$ran);
+    }
 }
 
 class TransactionUnawareTestEvent