14180031231

Committed 31 Mar 2025 07:42PM UTC coverage: 81.035% (+0.07%) from 80.964%

Build # 14180031231

Build Type

Pull #1103

github

Committed by

web-flow

Commit Message

Merge a0ac1bfe6 into 80e661e93

Pull Request Pull Request #1103: feat(event-bus): add event bus testing utilities

Run Details

56 of 57 new or added lines in 3 files covered. (98.25%)

11114 of 13715 relevant lines covered (81.04%)

102.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.0

/src/Tempest/EventBus/src/Testing/EventBusTester.php

<?php

namespace Tempest\EventBus\Testing;

use BackedEnum;
use Closure;
use PHPUnit\Framework\Assert;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\GeneratorNotSupportedException;
use Tempest\Container\Container;
use Tempest\EventBus\EventBus;
use Tempest\EventBus\EventBusConfig;
use UnitEnum;

final class EventBusTester
{
    private FakeEventBus $fakeEventBus;

    public function __construct(
        private readonly Container $container,
    ) {}

    /**
     * Prevents the registered event handlers from being called.
     */
    public function preventEventHandling(): self
    {
        $this->fakeEventBus = new FakeEventBus($this->container->get(EventBusConfig::class));
        $this->container->singleton(EventBus::class, $this->fakeEventBus);

        return $this;
    }

    /**
     * Asserts that the given `$event` has been dispatched.
     *
     * @param null|Closure $callback A callback accepting the event instance. The assertion fails if the callback returns `false`.
     * @param null|int $count If specified, the assertion fails if the event has been dispatched a different amount of times.
     */
    public function assertDispatched(string|object $event, ?Closure $callback = null, ?int $count = null): self
    {
        $this->assertFaked();

        Assert::assertNotNull(
            actual: $dispatches = $this->findDispatches($event),
            message: 'The event was not dispatched.',
        );

        if ($count !== null) {
            Assert::assertCount($count, $dispatches, 'The number of dispatches does not match.');
        }

        if ($callback !== null) {
            foreach ($dispatches as $dispatch) {
                Assert::assertNotFalse($callback($dispatch), 'The callback failed.');
            }
        }

        return $this;
    }

    /**
     * Asserts that the specified `$event` has not been dispatched.
     */
    public function assertNotDispatched(string|object $event): self
    {
        $this->assertFaked();

        Assert::assertEmpty($this->findDispatches($event), 'The event was dispatched.');

        return $this;
    }

    /**
     * Asserts that the specified `$event` is being listened to.
     *
     * @param null|int $count If specified, the assertion fails if there are a different amount of listeners.
     */
    public function assertListeningTo(string $event, ?int $count = null): self
    {
        $this->assertFaked();

        Assert::assertNotEmpty(
            actual: $handlers = $this->findHandlersFor($event),
            message: 'The event is not being listened to.',
        );

        if ($count !== null) {
            Assert::assertSame($count, count($handlers), 'The number of handlers does not match.');
        }

        return $this;
    }

    private function findDispatches(string|object $event): array
    {
        return array_filter($this->fakeEventBus->dispatched, function (string|object $dispatched) use ($event) {
            if ($dispatched === $event) {
                return true;
            }

            if (class_exists($event) && $dispatched instanceof $event) {
                return true;
            }

            return false;
        });
    }

    /** @return array<\Tempest\EventBus\CallableEventHandler> */
    private function findHandlersFor(string|object $event): array
    {
        $eventName = match (true) {
            $event instanceof BackedEnum => $event->value,
            $event instanceof UnitEnum => $event->name,
            is_string($event) => $event,
            default => $event::class,
        };

        return $this->fakeEventBus->eventBusConfig->handlers[$eventName] ?? [];
    }

    private function assertFaked(): self
    {
        Assert::assertTrue(isset($this->fakeEventBus), 'Asserting against the event bus require the `preventEventHandling()` method to be called first.');

        return $this;
    }
}

1	<?php
2
3	namespace Tempest\EventBus\Testing;
4
5	use BackedEnum;
6	use Closure;
7	use PHPUnit\Framework\Assert;
8	use PHPUnit\Framework\ExpectationFailedException;
9	use PHPUnit\Framework\GeneratorNotSupportedException;
10	use Tempest\Container\Container;
11	use Tempest\EventBus\EventBus;
12	use Tempest\EventBus\EventBusConfig;
13	use UnitEnum;
14
15	final class EventBusTester
16	{
17	private FakeEventBus $fakeEventBus;
18
19	public function __construct(	723✔
20	private readonly Container $container,
21	) {}	723✔
22
23	/**
24	* Prevents the registered event handlers from being called.
25	*/
26	public function preventEventHandling(): self	14✔
27	{
28	$this->fakeEventBus = new FakeEventBus($this->container->get(EventBusConfig::class));	14✔
29	$this->container->singleton(EventBus::class, $this->fakeEventBus);	14✔
30
31	return $this;	14✔
32	}
33
34	/**
35	* Asserts that the given `$event` has been dispatched.
36	*
37	* @param null\|Closure $callback A callback accepting the event instance. The assertion fails if the callback returns `false`.
38	* @param null\|int $count If specified, the assertion fails if the event has been dispatched a different amount of times.
39	*/
40	public function assertDispatched(string\|object $event, ?Closure $callback = null, ?int $count = null): self	7✔
41	{
42	$this->assertFaked();	7✔
43
44	Assert::assertNotNull(	6✔
45	actual: $dispatches = $this->findDispatches($event),	6✔
46	message: 'The event was not dispatched.',	6✔
47	);	6✔
48
49	if ($count !== null) {	6✔
50	Assert::assertCount($count, $dispatches, 'The number of dispatches does not match.');	2✔
51	}
52
53	if ($callback !== null) {	5✔
54	foreach ($dispatches as $dispatch) {	3✔
55	Assert::assertNotFalse($callback($dispatch), 'The callback failed.');	3✔
56	}
57	}
58
59	return $this;	3✔
60	}
61
62	/**
63	* Asserts that the specified `$event` has not been dispatched.
64	*/
65	public function assertNotDispatched(string\|object $event): self	3✔
66	{
67	$this->assertFaked();	3✔
68
69	Assert::assertEmpty($this->findDispatches($event), 'The event was dispatched.');	3✔
70
71	return $this;	1✔
72	}
73
74	/**
75	* Asserts that the specified `$event` is being listened to.
76	*
77	* @param null\|int $count If specified, the assertion fails if there are a different amount of listeners.
78	*/
79	public function assertListeningTo(string $event, ?int $count = null): self	4✔
80	{
81	$this->assertFaked();	4✔
82
83	Assert::assertNotEmpty(	4✔
84	actual: $handlers = $this->findHandlersFor($event),	4✔
85	message: 'The event is not being listened to.',	4✔
86	);	4✔
87
88	if ($count !== null) {	3✔
89	Assert::assertSame($count, count($handlers), 'The number of handlers does not match.');	2✔
90	}
91
92	return $this;	2✔
93	}
94
95	private function findDispatches(string\|object $event): array	9✔
96	{
97	return array_filter($this->fakeEventBus->dispatched, function (string\|object $dispatched) use ($event) {	9✔
98	if ($dispatched === $event) {	9✔
99	return true;	6✔
100	}
101
102	if (class_exists($event) && $dispatched instanceof $event) {	6✔
103	return true;	5✔
104	}
105
106	return false;	4✔
107	});	9✔
108	}
109
110	/** @return array<\Tempest\EventBus\CallableEventHandler> */
111	private function findHandlersFor(string\|object $event): array	4✔
112	{
113	$eventName = match (true) {	4✔
114	$event instanceof BackedEnum => $event->value,	4✔
115	$event instanceof UnitEnum => $event->name,	4✔
116	is_string($event) => $event,	4✔
NEW 117	default => $event::class,	×
118	};	4✔
119
120	return $this->fakeEventBus->eventBusConfig->handlers[$eventName] ?? [];	4✔
121	}
122
123	private function assertFaked(): self	14✔
124	{
125	Assert::assertTrue(isset($this->fakeEventBus), 'Asserting against the event bus require the `preventEventHandling()` method to be called first.');	14✔
126
127	return $this;	13✔
128	}
129	}

tempestphp / tempest-framework / 14180031231

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous