public function testLoadAndStoreAggregate()
 {
     DefaultUnitOfWork::startAndGet();
     $aggregate = new StubAggregate();
     $aggregate->doSomething();
     /*$this->lockManager->expects($this->exactly(2))
                 ->method('obtainLock')
                 ->with($this->equalTo($aggregate->getIdentifier()));
     
             $this->lockManager->expects($this->exactly(2))
                 ->method('releaseLock')
                 ->with($this->equalTo($aggregate->getIdentifier()));*/
     $this->testSubject->add($aggregate);
     CurrentUnitOfWork::commit();
     DefaultUnitOfWork::startAndGet();
     $loadedAggregate = $this->testSubject->load($aggregate->getIdentifier(), 0);
     //verify(lockManager).obtainLock(aggregate.getIdentifier());
     $loadedAggregate->doSomething();
     CurrentUnitOfWork::commit();
     /*  $lockManager = Phake::mock(get_class($this->lockManager));
     
             \Phake::inOrder(
             \Phake::verify($lockManager)->validateLock(),
             \Phake::verify($lockManager)->releaseLock()
             );*/
     //InOrder inOrder = inOrder(lockManager);
     // inOrder.verify(lockManager, atLeastOnce()).validateLock(loadedAggregate);
     // verify(mockEventBus, times(2)).publish(any(DomainEventMessage.class));
     // inOrder.verify(lockManager).releaseLock(loadedAggregate.getIdentifier());
 }
 /**
  * @CommandHandler
  */
 public function handleStrangeCommand(StrangeCommand $testCommand)
 {
     $aggregate = $this->repository->load($testCommand->getAggregateIdentifier(), null);
     $aggregate->doSomething();
     $this->eventBus->publish(new GenericEventMessage(new MyApplicationEvent()));
     CurrentUnitOfWork::get()->publishEvent(new GenericEventMessage(new MyApplicationEvent()), $this->eventBus);
     throw new StrangeCommandReceivedException("Strange command received");
 }
 public function testSetSession()
 {
     $mockUnitOfWork = $this->getMock(UnitOfWorkInterface::class);
     CurrentUnitOfWork::set($mockUnitOfWork);
     $this->assertSame($mockUnitOfWork, CurrentUnitOfWork::get());
     CurrentUnitOfWork::clear($mockUnitOfWork);
     $this->assertFalse(CurrentUnitOfWork::isStarted());
 }
 public function add(AggregateRootInterface $aggregateRoot)
 {
     if (null !== $aggregateRoot->getVersion()) {
         throw new \InvalidArgumentException("Only newly created (unpersisted) aggregates may be added.");
     }
     if (!$this->supportsClass(get_class($aggregateRoot))) {
         throw new \InvalidArgumentException(sprintf("This repository supports %s, but got %s", $this->className, get_class($aggregateRoot)));
     }
     CurrentUnitOfWork::get()->registerAggregate($aggregateRoot, $this->eventBus, $this->saveAggregateCallback);
 }
 public function testCommandHandlerLoadsSameAggregateTwice()
 {
     DefaultUnitOfWork::startAndGet();
     $stubAggregate = new StubAggregate($this->aggregateIdentifier);
     $stubAggregate->doSomething();
     $this->repository->add($stubAggregate);
     CurrentUnitOfWork::commit();
     DefaultUnitOfWork::startAndGet();
     $this->repository->load($this->aggregateIdentifier)->doSomething();
     $this->repository->load($this->aggregateIdentifier)->doSomething();
     CurrentUnitOfWork::commit();
     $es = $this->mockEventStore->readEvents("", $this->aggregateIdentifier);
     $this->assertTrue($es->hasNext());
     $this->assertEquals(0, $es->next()->getScn());
     $this->assertTrue($es->hasNext());
     $this->assertEquals(1, $es->next()->getScn());
     $this->assertTrue($es->hasNext());
     $this->assertEquals(2, $es->next()->getScn());
     $this->assertFalse($es->hasNext());
 }
 public function publish(array $events)
 {
     if (null === $this->connection) {
         throw new \RuntimeException("The AMQPTerminal has no connection configured.");
     }
     $channel = $this->connection->channel();
     if ($this->isTransactional) {
         $channel->tx_select();
     }
     try {
         if ($this->waitForAck) {
             $channel->confirm_select();
         }
         foreach ($events as $event) {
             $amqpMessage = $this->messageConverter->createAmqpMessage($event);
             $this->doSendMessage($channel, $amqpMessage);
         }
         if (CurrentUnitOfWork::isStarted()) {
             CurrentUnitOfWork::get()->registerListener(new ChannelTransactionUnitOfWorkListener($this->logger, $channel, $this));
         } elseif ($this->isTransactional) {
             $channel->tx_commit();
         } elseif ($this->waitForAck) {
             $channel->wait_for_pending_acks($this->publisherAckTimeout);
         }
     } catch (\Exception $ex) {
         if ($this->isTransactional) {
             $this->tryRollback($channel);
         }
         throw new EventPublicationFailedException("Failed to dispatch Events to the Message Broker.", 0, $ex);
     } finally {
         if (!CurrentUnitOfWork::isStarted()) {
             $this->tryClose($channel);
         }
     }
 }
 public function testDispatchCommand_ImplicitUnitOfWorkIsRolledBackOnException()
 {
     $command = new TestCommand("Say hi!");
     $test = $this;
     $this->handlerRegistry->subscribe(TestCommand::class, new CallbackCommandHandler(function (CommandMessageInterface $commandMessage, UnitOfWorkInterface $unitOfWork) use($test) {
         $test->assertTrue(CurrentUnitOfWork::isStarted());
         $test->assertNotNull(CurrentUnitOfWork::get());
         throw new \RuntimeException("exception");
     }));
     $callback = new ClosureCommandCallback(function ($result) use($command) {
         $this->fail("Did not expect exception");
     }, function ($exception) {
         $this->assertEquals(\RuntimeException::class, get_class($exception));
     });
     $this->commandBus->dispatch(GenericCommandMessage::asCommandMessage($command), $callback);
     $this->assertFalse(CurrentUnitOfWork::isStarted());
 }
 public function tearDown()
 {
     while (CurrentUnitOfWork::isStarted()) {
         CurrentUnitOfWork::get()->rollback();
     }
 }
 public function testLoadAndSaveWithoutConflictingChanges()
 {
     $conflictResolver = $this->getMock('Governor\\Framework\\EventSourcing\\ConflictResolverInterface');
     $identifier = Uuid::uuid1()->toString();
     $event2 = new GenericDomainEventMessage($identifier, 2, new \stdClass(), MetaData::emptyInstance());
     $event3 = new GenericDomainEventMessage($identifier, 3, new \stdClass(), MetaData::emptyInstance());
     $this->mockEventStore->expects($this->once())->method('readEvents')->with($this->identicalTo("test"), $this->identicalTo($identifier))->will($this->returnValue(new SimpleDomainEventStream(array(new GenericDomainEventMessage($identifier, 1, new \stdClass()), $event2, $event3))));
     $this->testSubject->setConflictResolver($conflictResolver);
     $actual = $this->testSubject->load($identifier, 3);
     $conflictResolver->expects($this->never())->method('resolveConflicts');
     $actual->apply(new StubDomainEvent());
     $conflictResolver->expects($this->never())->method('resolveConflicts');
     CurrentUnitOfWork::commit();
 }
 public function testInnerUnitOfWorkCommittedBackWithOuter()
 {
     $isCommitted = false;
     $outer = DefaultUnitOfWork::startAndGet();
     $inner = DefaultUnitOfWork::startAndGet();
     $inner->registerListener(new AfterCommitTestAdapter(function (UnitOfWorkInterface $uow) use(&$isCommitted) {
         $isCommitted = true;
     }));
     $inner->commit();
     $this->assertFalse($isCommitted, "The inner UoW was committed prematurely");
     $outer->commit();
     $this->assertTrue($isCommitted, "The inner UoW wasn't properly committed");
     $this->assertFalse(CurrentUnitOfWork::isStarted(), "The UnitOfWork haven't been correctly cleared");
 }
 protected function doLoad($id, $expectedVersion)
 {
     try {
         $events = $this->eventStore->readEvents($this->getTypeIdentifier(), $id);
     } catch (EventStreamNotFoundException $ex) {
         throw new AggregateNotFoundException($id, "The aggregate was not found", $ex);
     }
     foreach ($this->eventStreamDecorators as $decorator) {
         $events = $decorator->decorateForRead($this->getTypeIdentifier(), $id, $events);
     }
     $aggregate = $this->factory->createAggregate($id, $events->peek());
     $unseenEvents = array();
     $aggregate->initializeState(new CapturingEventStream($events, $unseenEvents, $expectedVersion));
     if ($aggregate->isDeleted()) {
         throw new AggregateDeletedException($id);
     }
     CurrentUnitOfWork::get()->registerListener(new ConflictResolvingListener($aggregate, $unseenEvents, $this->conflictResolver));
     return $aggregate;
 }