public function setUp()
{
$this->emitter = \Mockery::spy(Emitter::class);
$this->event = \Mockery::mock(EventInterface::class);
$this->message = DomainMessage::recordNow(0, 0, new Metadata(), $this->event);
$this->eventPublishingListener = new EventPublishingListener($this->emitter);
}
/**
* @test
*/
public function it_merges_the_metadata_instances_on_andMetadata()
{
$domainMessage = DomainMessage::recordNow('id', 42, Metadata::kv('bar', 1337), 'payload');
$newMessage = $domainMessage->andMetadata(Metadata::kv('foo', 42));
$expected = new Metadata(array('bar' => 1337, 'foo' => 42));
$this->assertEquals($expected, $newMessage->getMetadata());
}
/**
* @test
* @expectedException \Assert\InvalidArgumentException
*/
public function it_throws_an_exception_if_the_static_method_does_not_exist()
{
// make sure events exist in the event store
$id = 'y0l0';
$this->eventStore->append($id, new DomainEventStream(array(DomainMessage::recordNow(42, 0, new Metadata(array()), new DidEvent()))));
$repository = $this->repositoryWithStaticAggregateFactory('someUnknownStaticmethod');
$repository->load('y0l0');
}
/**
* @test
*/
public function it_loads_an_aggregate()
{
$this->eventStore->append(42, new DomainEventStream(array(DomainMessage::recordNow(42, 0, new Metadata(array()), new DidNumberEvent(1337)))));
$aggregate = $this->repository->load(42);
$expectedAggregate = $this->createAggregate();
$expectedAggregate->apply(new DidNumberEvent(1337));
$expectedAggregate->getUncommittedEvents();
$this->assertEquals($expectedAggregate, $aggregate);
}
public function setUp()
{
$this->event = \Mockery::mock(EventInterface::class);
$this->context = \Mockery::mock(Context::class);
$this->metadata = \Mockery::mock(Metadata::class);
$this->message = DomainMessage::recordNow('id', 0, $this->metadata, $this->event);
$this->handler = \Mockery::mock(MessageEventHandler::class);
$this->serviceUnderTest = new DomainMessageListener($this->handler);
}
/**
* @test
*/
public function when_appending_one_event_from_a_event_stream_fails_it_rolls_back_all_changes()
{
$this->expectException(IlluminateEventStoreException::class);
// this test is a bit of an hack, by mocking the DateTime object we make
// the append() method of the event store throw an exception
$time = $this->prophesize(\Broadway\Domain\DateTime::class);
$time->toString()->willThrow(new \Exception('This is an invalid event'));
$eventStream = new DomainEventStream([DomainMessage::recordNow('aggregate-1', 0, new Metadata(array()), new ADomainEvent()), new DomainMessage('aggregate-1', 1, new Metadata(array()), new ADomainEvent(), $time->reveal())]);
$this->store->append('aggregate-1', $eventStream);
}
private function toDomainEventStream(array $events)
{
$messages = array();
$playhead = -1;
foreach ($events as $event) {
$playhead++;
$messages[] = DomainMessage::recordNow(1, $playhead, new Metadata(array()), $event);
}
return new DomainEventStream($messages);
}
/**
* @test
*/
public function it_publishes_events_and_sensitive_date_to_subscribed_processors()
{
$domainMessage = DomainMessage::recordNow(1, 1, new Metadata([]), new \stdClass());
$sensitiveData = new SensitiveData(['foo' => 'bar']);
$processor1 = $this->prophesize(SensitiveDataEventListenerInterface::class);
$processor1->handle($domainMessage, $sensitiveData)->shouldBeCalled();
$processor2 = $this->prophesize(SensitiveDataEventListenerInterface::class);
$processor2->handle($domainMessage, $sensitiveData)->shouldBeCalled();
$manager = new SensitiveDataManager([$processor1->reveal(), $processor2->reveal()]);
$manager->setSensitiveData($sensitiveData);
$manager->handle($domainMessage);
}
public function eventHandling()
{
// Create the event bus and subscribe the created event listener
$eventBus = new SimpleEventBus();
$eventListener = new MyEventListener();
$eventBus->subscribe($eventListener);
// Create a domain event stream to publish
$metadata = new Metadata(['source' => 'example']);
$domainMessage = DomainMessage::recordNow(42, 1, $metadata, new stdClass());
$domainEventStream = new DomainEventStream([$domainMessage]);
// Publish the message, and get output from the event handler \o/
$eventBus->publish($domainEventStream);
}
public function attachExistingEvents($events, $id)
{
$messages = array();
foreach ($events as $event) {
$playhead = $this->getPlayhead($id);
$playhead++;
$messages[] = DomainMessage::recordNow($id, $playhead, new Metadata(array()), $event);
$this->playheads[$id] = $playhead;
}
$domainEventStream = new DomainEventStream($messages);
$this->store->append($id, $domainEventStream);
$this->eventBus->publish($domainEventStream);
}
/**
* @param array $givens
*
* @return Scenario
*/
public function given(array $givens = null)
{
if ($givens === null) {
return $this;
}
$messages = array();
$playhead = -1;
foreach ($givens as $event) {
$playhead++;
$messages[] = DomainMessage::recordNow($this->aggregateId, $playhead, new Metadata(array()), $event);
}
$this->aggregateRootInstance = $this->factory->create($this->aggregateRootClass, new DomainEventStream($messages));
return $this;
}
/**
* @param array $events
*
* @return Scenario
*/
public function given(array $events = null)
{
if ($events === null) {
return $this;
}
$messages = array();
$playhead = -1;
foreach ($events as $event) {
$playhead++;
$messages[] = DomainMessage::recordNow($this->aggregateId, $playhead, new Metadata(array()), $event);
}
$this->eventStore->append($this->aggregateId, new DomainEventStream($messages));
return $this;
}
/**
* Handles an error
*
* @param EventInterface $error
* @param mixed $context
*
* @return void
*/
public function handle(EventInterface $error, $context = null)
{
$this->eventBus->publish(new DomainEventStream([DomainMessage::recordNow(null, null, new Metadata([ContextEnricher::CONTEXT => $context]), $error)]));
}
private function createDomainMessage($playhead, $payload)
{
return DomainMessage::recordNow(1, $playhead, new Metadata([]), $payload);
}
/**
* Applies an event. The event is added to the AggregateRoot's list of uncommitted events.
*
* @param $event
*/
public function apply($event)
{
$this->handleRecursively($event);
$this->playhead++;
$this->uncommittedEvents[] = DomainMessage::recordNow($this->getAggregateRootId(), $this->playhead, new Metadata(array()), $event);
}
/**
* @test
*/
public function it_dispatches_label_added_commands_when_applying_organizer_updated_from_udb2()
{
$cdbXml = file_get_contents(__DIR__ . '/Samples/organizer.xml');
$cdbXmlNamespaceUri = \CultureFeed_Cdb_Xml::namespaceUriForVersion('3.3');
$organizerUpdatedFromUDB2 = new OrganizerUpdatedFromUDB2('0105bc28-2368-4f89-8ea1-001c6c301065', $cdbXml, $cdbXmlNamespaceUri);
$this->labelImporter->handle(DomainMessage::recordNow('0105bc28-2368-4f89-8ea1-001c6c301065', 1, new Metadata([]), $organizerUpdatedFromUDB2));
}
private function createDomainMessage($payload)
{
return DomainMessage::recordNow(1, 1, new Metadata(array()), new SimpleTestEvent($payload));
}
private function handleEvent($manager, $event)
{
$manager->handle(DomainMessage::recordNow(1, 0, new Metadata(array()), $event));
}
private function createDomainMessageForEvent($event)
{
$this->playhead++;
return DomainMessage::recordNow(1, $this->playhead, new Metadata(array()), $event);
}
private function createDomainMessage($event)
{
return DomainMessage::recordNow(1, 1, new Metadata([]), $event);
}
private function publish($payload)
{
$this->enricher->handle(DomainMessage::recordNow(UUID::generateAsString(), 0, new Metadata(), $payload));
}
private function createDomainEventStream()
{
$m1 = DomainMessage::recordNow('id', 42, Metadata::kv('bar', 1337), 'payload');
$m2 = DomainMessage::recordNow('id', 42, Metadata::kv('bar', 1337), 'payload');
return new DomainEventStream(array($m1, $m2));
}
