How to use the handle method on base test case

[samijnih]

Hello,

Thanks for the hard work on this project. I have a question regardless the handle method of the aggregate test case.

I really don't see the point of that method.

Let's take the example from the documentation:

<?php

use EventSauce\EventSourcing\AggregateRootId;
use EventSauce\EventSourcing\TestUtilities\AggregateRootTestCase;

abstract class SignUpProcessTestCase extends AggregateRootTestCase
{
    protected function newAggregateRootId(): AggregateRootId
    {
        return SignupId::create();
    }

    protected function aggregateRootClassName(): string
    {
        return SignUpProcess::class;
    }
    
    protected function handle(/* your arguments for when */)
    {
        // Implement me.
    }
}

I use commands in my system in order to perform mutations in my aggregate root.

I didn't get the point of this provided code sample:

    protected function handle(object $command)
    {
        if ($command instanceof SomeCommand) {
            $aggregate = $this->repository->retrieve($command->id());
            $aggregate->performAction();
            $this->repository->persist($aggregate);
        }
    }

In which case should I retrieve the aggregate root to perform an action (I put that in my command handler) and persist it?

Let's say I currently have this example code that I'd like to refactor using event-driven approch by using EventSaucePHP:

# Domain event
class FooWasRegistered
{
    public function __construct(private string $id, private string $title, private DateTimeImmutable $occurredOn) {}

    public static function messageName(): string
    {
        return 'foo_was_registered';
    }
}

# Aggregate root
class Foo implements AggregateRoot
{
    public function __construct(FooId $id, Title $title)
    {
        $this->id = $id->toString();
        $this->title = $title->toString();
    }

    public static function register(FooId $id, Title $title, ImmutableClock $clock): self
    {
        $foo = new self($id, $title);
        $foo->register(new FooWasRegistered($id, $title, $immutableClock->now()));
        
        return $foo;
    }
}

# Command
class RegisterFoo
{
    public function __construct(private string $id, private string $title) {}
    
    # getters
}

# Command handler
class HandleRegisterFoo
{
    public function __construct(
        private FooRepository $repository,
        private ImmutableClock $immutableClock,
        private EventBus $eventBus,
    ) {
    }
    
    public function handle(RegisterFoo $command): void
    {
        Foo::register(
            FooId::fromString($command->getId()),
            Title::fromString($command->getTitle()),
            $this->immutableClock
        );
        
        $this->repository->add($foo);
        
        $this->eventBus->dispatch($foo->releaseEvents());
    }
}

# Test case
class HandleRegisterFooTest extends TestCase
{
    private FooRepository $repository;
    private EventBus $eventBus;
    private HandleRegsiterFoo $sut;
    
    protected function setUp(): void
    {
        $this->repository = new InMemoryFooRepository();
        $this->eventBus = new InMemoryEventBus();
        
        $this->sut = new HandleRegisterFoo(
            $this->repository,
            new StaticImmutableClock(),
            $this->eventBus,
        );
    }
    
    public function it_registers_a_new_foo(): void
    {
        $command = new RegisterFoo('random id', 'Awesome title');
        
        $this->sut->handle($command);
        
        self::assertNotNull($this->repository->get('random id'));
        self::assertTrue($this->eventBus->hasNamed('foo_was_registered');
    }
}

I'd like to be sure what I put inside the handle method of my test case using EventSauce.

Thanks!

[samijnih]

My suggested answer to my own question is that I can call my command bus in the handle method of the test case.

Am I wrong?

[frankdejonge]

This is correct!