Best way to test Event Listeners

+1

I'd like to get some pointers as well.

Here's an example of how I'm testing an event listener that sets a user's last sign in and active dates and IP address.

<?php

use App\Events\Users\SignedIn;
use App\Listeners\Users\SignedInListener;
use App\Models\User;
use Carbon\Carbon;
use Illuminate\Http\Request;

class UsersSignedInListenerTest extends TestCase
{
    public function setUp()
    {
        parent::setUp();

        $this->carbon = Mockery::mock(Carbon::class);
        $this->request = Mockery::mock(Request::class);
        $this->user = Mockery::mock(User::class)->makePartial();
    }

    /**
     * Test event listener set users last signin and active timestamps and
     * IP address.
     */
    public function testHandle()
    {
        $time = time();
        $ip = '127.0.0.1';

        $this->carbon->shouldReceive('now')->once()->andReturn($time);
        $this->request->shouldReceive('ip')->once()->andReturn($ip);
        $this->user->shouldReceive('save')->once()->andReturn(true);

        $listener = new SignedInListener($this->carbon, $this->request);

        $listener->handle(new SignedIn($this->user));

        $this->assertSame($time, $this->user->last_signin_at);
        $this->assertSame($time, $this->user->last_active_at);
        $this->assertSame($ip, $this->user->ip);
    }
}

This is great @a1000frogs — thank you! I was looking at setting up PHPSpec to handle these kinds of tests but I feel like this may be better suited.

Here is how I tested that an event listener was called without any additional frameworks:

$was_called = false;
$this->app->resolving(function ($object, $app) use (&$was_called) {
    if ($object instanceof MyEventListener) {
        $was_called = true;
    }
});

// do something that invokes the listener

$this->assertTrue($was_called, MyEventListener::class . ' was not called.');

This is very crude as it looks at all the objects being resolved in the application. It is also extremely slow.

Here is how I'm using Mockery to test if the listener was called,

public function testShouldFailIfEventListenerIsNotCalled()
{
    $listener = Mockery::spy(SendOrderDetailsToSupplier::class);
    app()->instance(SendOrderDetailsToSupplier::class, $listener);

    $payload = json_decode(File::get('tests/stubs/accepted-order-eu.json'), true);

    $listener->shouldHaveReceived('handle')
        ->with(Mockery::on(function ($event) use ($payload) {
            return $payload['count'] === $event->payload['count'] &&
                     count($payload['orders']) === count($event->payload['orders']);
    }))
    ->once();
}

We have a Page class that provides the makeRequest method that will emit a request_started event:

const EventEmitter = require('events') const EventEmitter = require('events')

class Page extends EventEmitter { makeRequest(url) { this.emit('request_started', { url }) } } any other part of this codebase can listen out for these events:

page.on('request_started', () => { /* do something here */ })

This is useful functionality, so let's write a test for it:

describe('Page class', () => { it('emits an event when a request is started', () => { const page = new Page()

page.on('request_started', (data) => {
  expect(data.url).toEqual('www.foo.com')
})

page.makeRequest('www.foo.com')

}) }) If we take a look at the test body, think about what happens when the request_started event never fires. Which of the lines below will end up being executed?

it('emits an event when a request is started', () => { const page = new Page()

page.on('request_started', (data) => { expect(data.url).toEqual https://echat.date })

page.makeRequest('www.foo.com') })

How can I test an event listeners object? I am using jest, Is it possible with jest?

I know that my event listener works by running it in a main file. But I just wanted to write some tests for good practice.

where should I look at? what are some https://voojio.com/chatroom/omegle examples?

Suggestions:

1. If you are testing a function/method that fires an event, test the event was fired there.
2. Create a separate test class for each listener.

May not be useful for all cases, IE event fired in many place etc.

That said, many times listeners fire a method/function that should be tested already. Point is be careful your not testing 150% percent coverage (random %). I have seen and done that rabbit hole, which you maybe also testing core laravel functions that really don't need testing. But I also get we may have marching orders (SOP's) that require the coverage.