public ActionResult <ChapterDto> Create([FromBody] CreateChapterCommand command)
 {
     return(createChapterCommandHandler.Handle(command)
            .OnBoth((result) =>
     {
         return responseHandler.GetCreatedResponse(result, "GetChapter", new
         {
             chapterId = result.Value?.Id
         });
     }));
 }
        public async Task Handle_ValidChapterData_SaveShouldFailed()
        {
            //Arrange
            var command = new CreateChapterCommand()
            {
                Name         = "anonymousName",
                EnglishLevel = (int)EnglishLevel.Beginner
            };

            _chapterRepositoryMock.Setup(x => x.SaveAsync(It.IsAny <Chapter>()))
            .ReturnsAsync(false);

            //Act
            //Assert
            await Assert.ThrowsAsync <InvalidOperationException>(() => _chapterCommandHandler.Handle(command, CancellationToken.None));

            _autoMocker.VerifyAll();
        }
Example #3
0
        public async Task <ActionResult <SagaModel> > CreateChapter(
            [FromRoute] SagaReference reference,
            [FromBody] CreateChapterRequest request,
            CancellationToken cancellationToken)
        {
            var command = new CreateChapterCommand(reference.SagaId, request.Content);

            try
            {
                var response = await _sender.Send(command, cancellationToken);

                return(Ok(_mapper.Map <ChapterModel>(response)));
            }
            catch (SagaNotFoundException e)
            {
                return(NotFound(e.Message));
            }
        }
Example #4
0
        public async Task <IActionResult> Post([FromBody] CreateChapterCommand
                                               createChapterCommand)
        {
            using (var scope = _tracer.BuildSpan("CreateChapter").StartActive(finishSpanOnDispose: true))
            {
                try
                {
                    var userId = Guid.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
                    createChapterCommand.OwnerId = userId;
                    var response = await _mediator.Send(createChapterCommand);

                    return(Ok(response));
                }
                catch (Exception e)
                {
                    return(BadRequest(e));
                }
            }
        }
        public async Task Handle_ValidChapterData_ShouldSuccess()
        {
            //Arrange
            var command = new CreateChapterCommand()
            {
                Name         = "anonymousName",
                EnglishLevel = (int)EnglishLevel.Beginner
            };

            _chapterRepositoryMock.Setup(x => x.SaveAsync(It.IsAny <Chapter>()))
            .Callback <Chapter>(x => x.Id = Guid.NewGuid())
            .ReturnsAsync(true);
            //Act

            var result = await _chapterCommandHandler.Handle(command, CancellationToken.None);

            //Assert
            Assert.NotEqual(Guid.Empty, result);
            _autoMocker.VerifyAll();
        }