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());
}
public function testLockFailsOnConcurrentModification()
{
$identifier = Uuid::uuid1()->toString();
$aggregate1 = new StubAggregate($identifier);
$aggregate2 = new StubAggregate($identifier);
$manager = new OptimisticLockManager();
$manager->obtainLock($aggregate1->getIdentifier());
$manager->obtainLock($aggregate2->getIdentifier());
$aggregate1->doSomething();
$aggregate2->doSomething();
$this->assertTrue($manager->validateLock($aggregate1));
$this->assertFalse($manager->validateLock($aggregate2));
}
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 testInitializeFromAggregateSnapshot()
{
$aggregate = new StubAggregate("stubId");
$aggregate->doSomething();
$aggregate->commitEvents();
$snapshotMessage = new GenericDomainEventMessage($aggregate->getIdentifier(), $aggregate->getVersion(), $aggregate);
$factory = new GenericAggregateFactory(get_class($aggregate));
$this->assertEquals("StubAggregate", $factory->getTypeIdentifier());
$this->assertSame($aggregate, $factory->createAggregate($aggregate->getIdentifier(), $snapshotMessage));
}
