/** * @param Uuid $id * @return User * @throws ObjectNotFoundException */ public function getUser(Uuid $id) { $user = $this->storage->find($id->getValue()); if ($user == null) { throw new ObjectNotFoundException('User', $id); } return $user; }
/** * @param Uuid $id * @return Book * @throws ObjectNotFoundException */ public function getBook(Uuid $id) { $book = $this->storage->find($id->getValue()); if ($book === null) { throw new ObjectNotFoundException('Book', $id); } return $book; }
public function testSerialization() { $uuid = Uuid::createNew(); $serialized = $uuid->serialize(); $deserialized = Uuid::deserialize($serialized); self::assertEquals($uuid->getValue(), $deserialized->getValue()); }
public function testSerialization() { $id = Uuid::createNew(); $user = new User($id, 'foo', 'bar', 'name', 1); $serialized = $user->serialize(); $deserialized = User::deserialize($serialized); self::assertEquals($user, $deserialized); }
public function testSerialization() { $id = Uuid::createNew(); $book = new Book($id, new Authors(), 'title', 'isbn', false, 1); $serialized = $book->serialize(); $deserialized = Book::deserialize($serialized); self::assertEquals($book, $deserialized); }
public function testCheckInIsIdempotent() { $id = Uuid::createNew(); $book = new Book($id); $book->checkIn(); $events = $book->getUncommittedChanges()->getIterator()->getArrayCopy(); self::assertCount(0, $events); }
public function testGetByUserNameActionThrowsNotFoundExceptionIfNotFound() { self::setExpectedException(NotFoundHttpException::class); $id = Uuid::createNew(); $user = new User($id, 'user', 'email', 'name', 0); $this->service->expects(self::once())->method('getUserByUserName')->with('user')->will(self::returnValue(null)); $fetcher = $this->getMockBuilder(ParamFetcherInterface::class)->getMockForAbstractClass(); $fetcher->expects(self::once())->method('get')->with('user_name')->will(self::returnValue('user')); $controller = new UsersController($this->viewBuilder, $this->service, $this->commandBus); $view = $controller->getByUserNameAction($fetcher); }
public function testGetUserByEmailAddressReturnsFoundUser() { $id = Uuid::createNew(); $user = new User($id, 'user', 'foo', 'name', 0); $storage = $this->getMockBuilder(Storage::class)->disableOriginalConstructor()->getMock(); $storage->expects(self::once())->method('findBy')->with(['userName' => 'user'], 0, 1)->will(self::returnValue([$user])); $service = new UserService($storage); $actualUser = $service->getUserByUserName('user'); self::assertInstanceOf(User::class, $actualUser); self::assertEquals($user->getId(), $actualUser->getId()); }
public function testCreateUserHandlerWillCallStoreOnRepository() { $id = Uuid::createNew(); $userName = '******'; $emailAddress = 'bar'; $fullName = 'baz boo'; $command = new CreateUser($id, $userName, $emailAddress, $fullName); $user = User::create($command->getId(), $command->getUserName(), $command->getEmailAddress(), $command->getFullName()); $repository = $this->getMockBuilder(Repository::class)->disableOriginalConstructor()->getMock(); $repository->expects(self::once())->method('store')->with($user); $handler = new CreateUserHandler($repository); $handler->handle($command); }
public function testReturnBookHandlerWillCallStoreOnRepository() { $bookId = Uuid::createNew(); $command = new ReturnBook($bookId, 0); $book = Book::add($bookId, [], 'title', 'isbn'); $repository = $this->getMockBuilder(Repository::class)->disableOriginalConstructor()->getMock(); $repository->expects(self::once())->method('findById')->with($bookId)->will(self::returnValue($book)); $repository->expects(self::once())->method('store')->will(self::returnCallback(function (Book $actual) use($book) { self::assertEquals($book->getId(), $actual->getId()); })); $handler = new ReturnBookHandler($repository); $handler->handle($command); }
public function testAddBookHandlerWillCallStoreOnRepository() { $id = Uuid::createNew(); $title = 'foo'; $authors = [new AddAuthor($id, 'first', 'last', -1)]; $isbn = 'isbn'; $command = new AddBook($id, $authors, $title, $isbn); $book = Book::add($command->getId(), $command->getAuthors(), $command->getTitle(), $command->getISBN()); $repository = $this->getMockBuilder(Repository::class)->disableOriginalConstructor()->getMock(); $repository->expects(self::once())->method('store')->with($book); $handler = new AddBookHandler($repository); $handler->handle($command); }
public function testFindUserByIdLoadsUserFromHistory() { $userId = Uuid::createNew(); $userName = '******'; $emailAddress = 'bar'; $fullName = 'baz boo'; $expectedUser = User::create($userId, $userName, $emailAddress, $fullName); $events = new Events([new UserCreated($userId, $userName, $emailAddress, $fullName)]); $storage = $this->getMockBuilder(EventStore::class)->disableOriginalConstructor()->getMock(); $storage->expects(self::once())->method('getEventsForAggregate')->with($userId)->will(self::returnValue($events)); $repository = new Users($storage); $actualUser = $repository->findById($userId); self::assertEquals($expectedUser->getId(), $actualUser->getId()); }
public function testExecuteRetrievesIdentitiesFromEventStoreAndInsertsDocumentsIntoReadStore() { $eventStore = $this->getMockBuilder(EventStore::class)->disableOriginalConstructor()->getMock(); $readStore = $this->getMockBuilder(Storage::class)->disableOriginalConstructor()->getMock(); $identities = [Uuid::createFromValue(1), Uuid::createFromValue(2), Uuid::createFromValue(3), Uuid::createFromValue(4), Uuid::createFromValue(5)]; $eventStore->expects(self::once())->method('getAggregateIds')->will(self::returnValue($identities)); $eventStore->expects(self::exactly(count($identities)))->method('getEventsForAggregate')->will(self::returnCallback(function (Uuid $id) { return new Events([new BookAdded($id, [new AuthorAdded($id, 'first', 'last')], 'title', 'isbn'), new AuthorAdded($id, 'first', 'last'), new BookCheckedOut($id, Uuid::createNew())]); })); $readStore->expects(self::exactly(count($identities)))->method('upsert'); $in = $this->getMockBuilder(InputInterface::class)->getMockForAbstractClass(); $out = $this->getMockBuilder(OutputInterface::class)->getMockForAbstractClass(); $reload = new ReloadBookReadStore($eventStore, $readStore); $reload->run($in, $out); }
public function testCreateFromReadModelMapsDocumentToResource() { $id = Uuid::createNew(); $authors = new Authors(); $title = 'title'; $isbn = 'isbn'; $available = true; $version = 1; $document = new BookDocument($id, $authors, $title, $isbn, $available, $version); $resource = BookResource::createFromReadModel($document); self::assertEquals($id, $resource->getId()); self::assertEquals($title, $resource->getTitle()); self::assertEquals($isbn, $resource->getISBN()); self::assertEquals($available, $resource->isAvailable()); }
public function testFindBookByIdLoadsBookFromHistory() { $bookId = Uuid::createNew(); $title = 'foo'; $isbn = 'isbn'; $authors = []; $authorFirstName = 'first'; $authorLastName = 'last'; $expectedBook = Book::add($bookId, $authors, $title, $isbn); $expectedBook->addAuthor($authorFirstName, $authorLastName); $events = new Events([new BookAdded($bookId, $authors, $title, $isbn), new AuthorAdded($bookId, $authorFirstName, $authorLastName)]); $storage = $this->getMockBuilder(EventStore::class)->disableOriginalConstructor()->getMock(); $storage->expects(self::once())->method('getEventsForAggregate')->with($bookId)->will(self::returnValue($events)); $repository = new Books($storage); $actualBook = $repository->findById($bookId); self::assertEquals($expectedBook->getId(), $actualBook->getId()); }
/** * @param array $data * @return User */ public static function deserialize(array $data) { assert(array_key_exists('id', $data)); assert(array_key_exists('userName', $data)); assert(array_key_exists('emailAddress', $data)); assert(array_key_exists('fullName', $data)); assert(array_key_exists('version', $data)); return new self(Uuid::deserialize($data['id']), $data['userName'], $data['emailAddress'], $data['fullName'], $data['version']); }
/** * @param array $data * @return Book */ public static function deserialize(array $data) { assert(array_key_exists('id', $data)); assert(array_key_exists('authors', $data)); assert(array_key_exists('title', $data)); assert(array_key_exists('isbn', $data)); assert(array_key_exists('available', $data)); assert(array_key_exists('version', $data)); return new self(Uuid::deserialize($data['id']), Authors::deserialize($data['authors']), $data['title'], $data['isbn'], $data['available'], $data['version']); }
public function testBookIsAvailableAfterBookAdded() { $bookId = Uuid::createNew(); $title = 'foo'; $isbn = 'bar'; $firstName = 'bar'; $lastName = 'baz'; $authors = [new AuthorAdded($bookId, $firstName, $lastName)]; $storage = new MemoryStorage(); $service = new BookService($storage); $service->on(new BookAdded($bookId, $authors, $title, $isbn)); $book = $service->getBook($bookId); self::assertEquals($bookId, $book->getId()); self::assertEquals($title, $book->getTitle()); self::assertTrue($book->isAvailable()); foreach ($book->getAuthors()->getIterator() as $author) { /* @var $author Author */ self::assertEquals($firstName, $author->getFirstName()); self::assertEquals($lastName, $author->getLastName()); } }
public function testApplyConverterOnUserCreatesUser() { $id = Uuid::createNew(); $user = new UserReadModel($id, 'user', 'email', 'name', 1); $request = Request::createFromGlobals(); $request->attributes->set('id', $id); $this->userService->expects(self::once())->method('getUser')->with($id)->will(self::returnValue($user)); $this->configuration->expects(self::once())->method('getOptions')->will(self::returnValue(['id' => 'id'])); $this->configuration->expects(self::atLeastOnce())->method('getClass')->will(self::returnValue(UserResource::class)); $this->configuration->expects(self::atLeastOnce())->method('getName')->will(self::returnValue('user')); $converter = new ParamConverter($this->bookService, $this->userService); $converter->apply($request, $this->configuration); self::assertEquals($user->getId()->getValue(), $request->attributes->get('user')->getId()->getValue()); }
/** * @Rest\Put("", * condition="request.headers.get('content-type') matches '/domain-model=create-user/i'" * ) * @Rest\View() * * @ParamConverter("userResource", * class="AppBundle\Controller\Resource\User", * converter="fos_rest.request_body" * ) * * @param UserResource $userResource * @return View * @throws HttpException */ public function createAction(UserResource $userResource) { $user = $this->userService->getUserByUserName($userResource->getUserName()); if ($user != null) { return $this->viewBuilder->setStatus(204)->setVersion($user)->setLocation(static::BASE_ROUTE . $user->getId())->build(); } $id = Uuid::createNew(); $command = new CreateUser($id, $userResource->getUserName(), $userResource->getEmailAddress(), $userResource->getFullName()); $this->commandBus->send($command); $user = $this->userService->getUser($id); return $this->viewBuilder->setDocument($user)->setVersion()->setLocation(static::BASE_ROUTE . $user->getId())->setStatus(201)->build(); }
/** * @param Uuid $bookId */ public function __construct(Uuid $bookId) { parent::__construct(sprintf(static::$messageTemplate, $bookId->getValue())); }
public function testReturnBookSendsReturnBookCommand() { $this->commandBus->expects(self::once())->method('send')->will(self::returnCallback(function (Command $command) { self::assertInstanceOf(ReturnBook::class, $command); })); $id = Uuid::createNew(); $controller = new BooksController($this->viewBuilder, $this->service, $this->commandBus); $controller->returnBookAction($id, 0); }
public function getId() { return Uuid::createFromValue(1); }
/** * @param Request $request * @param ParamConfiguration $configuration * @return Uuid * @throws BadRequestHttpException */ protected function convertUuid(Request $request, ParamConfiguration $configuration) { $uuid = $request->attributes->get($configuration->getName()); if (empty($uuid)) { throw new BadRequestHttpException("Uuid value of '{$configuration->getName()}' must not be empty."); } return Uuid::createFromValue($uuid); }
/** * @Rest\Put("/{id}", * condition="request.headers.get('content-type') matches '/domain-model=checkout/i'", * requirements={ * "id"="[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}" * }, * defaults={ * "id"=null * } * ) * @Rest\View(statusCode=204) * * @ParamConverter("id", * class="AppBundle\EventSourcing\EventStore\Uuid", * converter="param_converter" * ) * @ParamConverter("version", * class="AppBundle\Domain\ReadModel\Book", * options={ * "id": "id" * }, * converter="param_converter" * ) * @Rest\QueryParam( * name="user_id", * key=null, * requirements="[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}", * default=null, * description="The user ID of the user that checks out the book.", * strict=true, * array=false, * nullable=false * ) * * @param Uuid $id * @param integer $version * @param ParamFetcherInterface $params * @throws HttpException */ public function checkOutBookAction(Uuid $id, $version, ParamFetcherInterface $params) { $userId = Uuid::createFromValue($params->get('user_id')); $command = new CheckOutBook($id, $userId, $version); try { $this->commandBus->send($command); } catch (BookUnavailableException $e) { throw new PreconditionFailedHttpException($e->getMessage(), $e); } }
/** * @param string $objectName * @param Uuid $objectId */ public function __construct($objectName, Uuid $objectId) { parent::__construct(sprintf(static::$messageTemplate, $objectName, $objectId->getValue())); }
/** * @return Uuid[] */ public function getAggregateIds() { return array_map(function ($identity) { return Uuid::createFromValue($identity); }, $this->storage->findIdentities()); }
public function testAppendEventForExistingAggregateWithWrongPlayheadThrowsException() { self::setExpectedException(ConcurrencyException::class); $aggregateId = Uuid::createNew(); $events = new Events([new FirstEvent()]); $eventBus = $this->getEventBus(); $storage = new MemoryEventStorage(); $serializer = $this->getSerializer(); $map = $this->getEventClassMap(); $store = new EventStore($eventBus, $storage, $serializer, $map); $store->save($aggregateId, $events, -1); $store->save($aggregateId, new Events([new SecondEvent()]), 1); }