[11.x] Allow multiple events to be dispatched at once

src/Illuminate/Contracts/Events/Dispatcher.php

@@ -48,6 +48,14 @@ public function until($event, $payload = []);
      */
     public function dispatch($event, $payload = [], $halt = false);
 
+    /**
+     * Dispatch multiple events and call their listeners.
+     *
+     * @param  array<int|string, mixed>  $events
+     * @return void
+     */
+    public function dispatchMultiple($events);
+
     /**
      * Register an event and payload to be fired later.
      *

src/Illuminate/Events/Dispatcher.php

@@ -268,6 +268,27 @@ public function dispatch($event, $payload = [], $halt = false)
         return $halt ? null : $responses;
     }
 
+    /**
+     * Dispatch multiple events and call their listeners.
+     *
+     * @param  array<int|string, mixed>  $events
+     * @return void
+     */
+    public function dispatchMultiple($events)
+    {
+        foreach ($events as $event => $payload) {
+            // If the key is an integer, we can assume we are dealing with an array and not a hashmap.
+            if (is_int($event)) {
+                // The payload is the event itself.
+                $this->dispatch($payload);
+
+                continue;
+            }
+
+            $this->dispatch($event, $payload);
+        }
+    }
+
     /**
      * Parse the given event and payload and prepare them for dispatching.
      *

src/Illuminate/Events/NullDispatcher.php

@@ -40,6 +40,17 @@ public function dispatch($event, $payload = [], $halt = false)
         //
     }
 
+    /**
+     * Don't fire multiple events.
+     *
+     * @param  array<int|string, mixed>  $events
+     * @return void
+     */
+    public function dispatchMultiple($events)
+    {
+        //
+    }
+
     /**
      * Don't register an event and payload to be fired later.
      *

src/Illuminate/Support/Facades/Event.php

@@ -14,6 +14,7 @@
  * @method static void subscribe(object|string $subscriber)
  * @method static mixed until(string|object $event, mixed $payload = [])
  * @method static array|null dispatch(string|object $event, mixed $payload = [], bool $halt = false)
+ * @method static void dispatchMultiple(array $events)
  * @method static array getListeners(string $eventName)
  * @method static \Closure makeListener(\Closure|string|array $listener, bool $wildcard = false)
  * @method static \Closure createClassListener(string $listener, bool $wildcard = false)

src/Illuminate/Support/Testing/Fakes/EventFake.php

@@ -303,6 +303,26 @@ public function dispatch($event, $payload = [], $halt = false)
         }
     }
 
+    /**
+     * Dispatch multiple events and call their listeners.
+     *
+     * @param  array<int|string, mixed>  $events
+     * @return void
+     */
+    public function dispatchMultiple($events)
+    {
+        foreach ($events as $event => $payload) {
+            if (is_int($event)) {
+                // The payload is the event itself.
+                $this->dispatch($payload);
+
+                continue;
+            }
+
+            $this->dispatch($event, $payload);
+        }
+    }
+
     /**
      * Determine if an event should be faked or actually dispatched.
      *

tests/Events/EventsDispatcherTest.php

@@ -37,6 +37,59 @@ public function testBasicEventExecution()
         $this->assertSame('barbar', $_SERVER['__event.test']);
     }
 
+    public function testMultipleEventsCanBeDispatchedArray()
+    {
+        unset($_SERVER['__event.test_foo']);
+        unset($_SERVER['__event.test_bar']);
+        $d = new Dispatcher;
+        $d->listen('foo', fn ($foo) => $_SERVER['__event.test_foo'] = $foo);
+        $d->listen('bar', fn ($bar) => $_SERVER['__event.test_bar'] = $bar);
+        $d->dispatchMultiple([
+            'foo' => 'bar',
+            'bar' => 'baz',
+        ]);
+
+        $this->assertSame('bar', $_SERVER['__event.test_foo']);
+        $this->assertSame('baz', $_SERVER['__event.test_bar']);
+    }
+
+    public function testMultipleEventsCanBeDispatchedArrayNoPayload()
+    {
+        unset($_SERVER['__event.test_foo']);
+        unset($_SERVER['__event.test_bar']);
+        $d = new Dispatcher;
+        $d->listen('foo', fn () => $_SERVER['__event.test_foo'] = 1);
+        $d->listen('bar', fn () => $_SERVER['__event.test_bar'] = 2);
+        $d->dispatchMultiple([
+            'foo',
+            'bar'
+        ]);
+
+        $this->assertSame(1, $_SERVER['__event.test_foo']);
+        $this->assertSame(2, $_SERVER['__event.test_bar']);
+    }
+
+    public function testMultipleEventsCanBeDispatchedObject()
+    {
+        unset($_SERVER['__event.test_foo']);
+        unset($_SERVER['__event.test_bar']);
+        $d = new Dispatcher;
+
+        $d->listen(ExampleEvent::class, function () {
+            $_SERVER['__event.test_foo'] = 'one';
+        });
+        $d->listen(AnotherEvent::class, function () {
+            $_SERVER['__event.test_bar'] = 'two';
+        });
+        $d->dispatchMultiple([
+            new ExampleEvent,
+            new AnotherEvent
+        ]);
+
+        $this->assertSame('one', $_SERVER['__event.test_foo']);
+        $this->assertSame('two', $_SERVER['__event.test_bar']);
+    }
+
     public function testHaltingEventExecution()
     {
         unset($_SERVER['__event.test']);

tests/Integration/Events/EventFakeTest.php

@@ -138,6 +138,42 @@ public function testEventsListedInExceptAreProperlyDispatched()
         $this->assertEquals(['important'], Event::dispatch('important-event'));
     }
 
+    public function testEventsAreFakedWhenMultipleDispatchedObject()
+    {
+        Event::fake();
+
+        Event::dispatchMultiple([new NonImportantEvent(), new AnotherEvent()]);
+
+        Event::assertDispatched(NonImportantEvent::class);
+        Event::assertDispatched(AnotherEvent::class);
+    }
+
+    public function testEventsAreFakedWhenMultipleDispatchedArray()
+    {
+        Event::fake();
+
+        Event::dispatchMultiple([
+            NonImportantEvent::class => 'foo',
+            AnotherEvent::class => 'bar'
+        ]);
+
+        Event::assertDispatched(NonImportantEvent::class);
+        Event::assertDispatched(AnotherEvent::class);
+    }
+
+    public function testEventsAreFakedWhenMultipleDispatchedArrayNoPayload()
+    {
+        Event::fake();
+
+        Event::dispatchMultiple([
+            NonImportantEvent::class,
+            AnotherEvent::class
+        ]);
+
+        Event::assertDispatched(NonImportantEvent::class);
+        Event::assertDispatched(AnotherEvent::class);
+    }
+
     public function testAssertListening()
     {
         Event::fake();
@@ -201,6 +237,11 @@ class NonImportantEvent
     //
 }
 
+class AnotherEvent
+{
+
+}
+
 class PostEventSubscriber
 {
     public function handlePostCreated($event)