public async Task GivenValidUpdateRequest_WhenTheArticleDoesNotExist_ReturnsErrorViewModelWithNotFound()
{
// Arrange
var updateArticleCommand = new UpdateArticleCommand
{
Slug = "this-is-not-an-article",
Article = new UpdateArticleDto
{
Body = "This is the new body!",
Title = "My new title!"
}
};
var requestContent = await ContentHelper.GetRequestContentWithAuthorization(updateArticleCommand, Client, IntegrationTestConstants.SecondaryUser);
// Act
var response = await Client.PutAsync($"{ArticlesEndpoint}/{updateArticleCommand.Slug}", requestContent);
var responseContent = await ContentHelper.GetResponseContent <ErrorViewModel>(response);
// Assert
response.StatusCode.ShouldBe(HttpStatusCode.NotFound);
responseContent.Errors.ShouldNotBeNull();
}
public void AddOrUpdate(ArticleModel model)
{
Article article = new Article(
model.Id
, model.Author
, model.Title
, model.TextSection
, model.Content
, Enum.Parse <ArticleType>(model.ArticleType)
, Convert.ToBoolean(model.IsDraft)
, model.IsSendEmail);
if (article.Id > 0)
{
UpdateArticleCommand updateArticleCommand = new UpdateArticleCommand(article);
_eventBus.Publish(updateArticleCommand);
}
else
{
CreateArticleCommand createArticleCommand = new CreateArticleCommand(article);
_eventBus.Publish(createArticleCommand);
}
}
public async Task GivenValidRequest_WhenTheUserOwnsTheArticle_ReturnsUpdatedArticleResponse()
{
// Arrange, retrieve the original article information
var stubArticleDto = new UpdateArticleDto
{
Body = "This isn't my article!",
Description = "Or is it?",
Title = "I'm a hacker trying to hack hacky articles about hacking."
};
var updateArticleCommand = new UpdateArticleCommand
{
Slug = "why-beer-is-gods-gift-to-the-world",
Article = stubArticleDto
};
// Act
var request = new UpdateArticleCommandHandler(_logger, Context, CurrentUserContext, Mapper, MachineDateTime);
var result = await request.Handle(updateArticleCommand, CancellationToken.None);
// Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <ArticleViewModel>();
result.Article.Body.ShouldBe(stubArticleDto.Body);
result.Article.Description.ShouldBe(stubArticleDto.Description);
result.Article.Title.ShouldBe(stubArticleDto.Title);
result.Article.TagList.ShouldContain("beer");
// Validate the article in the DB context
var updatedArticle = Context.Articles.FirstOrDefault(a =>
string.Equals(a.Slug, stubArticleDto.Title.ToSlug(), StringComparison.OrdinalIgnoreCase));
updatedArticle.ShouldNotBeNull();
updatedArticle.Body.ShouldBe(stubArticleDto.Body);
updatedArticle.Description.ShouldBe(stubArticleDto.Description);
updatedArticle.Title.ShouldBe(stubArticleDto.Title);
}
public async Task <IActionResult> UpdateArticle([FromBody] UpdateArticleCommand command)
{
try
{
var response = await _mediator.Send(command);
if (response != null)
{
if (response.IsSuccessful)
{
return(Ok());
}
else
{
return(BadRequest(response.FailureReason));
}
}
}
catch (Exception ex)
{
// _logger.LogError();
}
return(BadRequest());
}
public async Task TestHandle_UserIsNotAuthor_ShouldThrowBadRequestException(string slug)
{
// Arrange
var article = new Article(slug, null, null, new DateTime(),
new UserProfile(string.Empty, string.Empty, string.Empty));
Context.Articles.Add(article);
await Context.SaveChangesAsync();
var currentUserMock = new Mock <ICurrentUserService>();
var command = new UpdateArticleCommand
{
Slug = slug
};
var sut = new UpdateArticleCommand.Handler(Context, currentUserMock.Object);
// Act
var act = new Func <Task <Unit> >(async() => await sut.Handle(command, CancellationToken.None));
// Assert
act.Should().Throw <BadRequestException>();
}
public async Task Update_InvalidObject_ReturnsFalse()
{
//Arrange
var articleForUpdate = new ArticleForUpdateDto()
{
Id = 999,
Name1 = "1st article Updated",
SupplierId = "sup id",
SupplierReference = "sup ref",
PurchasePrice = 99.99M
};
var updateArticleCommand = new UpdateArticleCommand(_unitOfWorkMock.Object, _writeMapper);
_articleRepositoryMock.Setup(r => r.GetArticleByIdAsync(articleForUpdate.Id)).Returns(Task.FromResult(_testArticles.First()));
_unitOfWorkMock.Setup(uow => uow.Commit()).Returns(Task.FromResult(false));
//Act
var result = await updateArticleCommand.Execute(articleForUpdate);
//Assert
_articleRepositoryMock.Verify(r => r.GetArticleByIdAsync(It.IsAny <int>()), Times.Once);
_articleRepositoryMock.Verify(r => r.Update(It.IsAny <Article>()), Times.Once);
Assert.That(result, Is.EqualTo(false));
}
public void Update(UpdateArticleCommand command)
{
command.Validate();
if (AddNotifications(command))
{
return;
}
ArticleCategory category = _categoryRepository.GetById(command.CategoryId);
Article article = _articleRepository.GetById(command.ArticleId);
LedgerIdentityUser user = _identityResolver.GetUser();
if (NotifyNullCategory(category) || NotifyNullArticle(article))
{
return;
}
article = new Article(command.ArticleId, command.Slug, command.Title, command.Body, command.CategoryId, user.Id);
_articleRepository.Update(article);
Commit();
}
public void TestUpdateArticleCommand_ArticleNotFound()
{
var mediator = new Mock <IMediator>();
var articleRepo = new Mock <IArticleRepo>();
articleRepo.Setup(x => x.GetById(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult((Article)null));
var author = new Author()
{
Id = Guid.NewGuid(), FirstName = "Firstname", LastName = "Lastname"
};
var authorRepo = new Mock <IAuthorRepo>();
authorRepo.Setup(x => x.GetById(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(author));
var updateCommand = new UpdateArticleCommand()
{
Id = Guid.NewGuid(), AuthorId = author.Id, Heading = "heading", Text = "Text", Year = 2020
};
var handler = new UpdateArticleCommand.Handler(articleRepo.Object, authorRepo.Object, mediator.Object);
Assert.ThrowsAsync <NotFoundException>(() => handler.Handle(updateCommand, new CancellationToken()));
}
public async Task <HandleResultDto> EditArticle([FromBody] UpdateArticleCommand cmd)
{
return(await _mediator.Send(cmd, HttpContext.RequestAborted));
}
public async Task <ActionResult <Article> > Update([FromBody] UpdateArticleCommand request)
{
var article = await mediator.Send(request);
return(Ok());
}
public Task <Article> Handle(UpdateArticleCommand request, CancellationToken cancellationToken)
{
request.Article.UpdatedTs = DateTime.UtcNow;
return(_dbContext.WithConnectionAsync(connection => connection.QueryFirstAsync <Article>(UpdateSql, request.Article)));
}
public async Task <ArticleViewModel> UpdateArticle([FromBody] UpdateArticleCommand command, string slug)
{
_logger.LogInformation($"Updating article [{slug}]");
command.Slug = slug;
return(await Mediator.Send(command));
}
public async Task <ArticleDetailWrapper> UpdateArticle([FromRoute] string slug, [FromBody] UpdateArticleCommand command)
{
command.Article.Slug = slug;
return(await _mediator.Send(command));
}
public void CreateArticleCommandValidationShouldReturnFalse()
{
var request = new UpdateArticleCommand();
updateArticleCommandValidator.Validate(request).IsValid.Should().BeFalse();
}
public async Task <Response <int> > Update(UpdateArticleCommand command)
{
return(await Mediator.Send(command));
}
public Task <ResultWrapper <UpdateArticleOutput> > Handle(UpdateArticleCommand request, CancellationToken cancellationToken)
{
ResultWrapper <UpdateArticleOutput> updateArticleResult = new ResultWrapper <UpdateArticleOutput>();
try
{
using (TransactionScope transaction = new TransactionScope(TransactionScopeOption.RequiresNew))
{
TArticle tArticle = _dbContext.TArticle
.Include(x => x.TArticleSports)
.FirstOrDefault(x => x.Id == request.Id);
if (tArticle == null)
{
updateArticleResult.Status = false;
updateArticleResult.Message = "this Article doesn't exists!";
return(Task.FromResult(updateArticleResult));
}
tArticle.Title = request.Title;
tArticle.Summary = request.Summary;
tArticle.Image = request.Image;
tArticle.Content = request.Content;
tArticle.Image = request.Image;
tArticle.Enabled = request.Enabled;
_dbContext.TArticle.Update(tArticle);
_dbContext.SaveChanges();
// Article Sports
List <TArticleSport> ArticleSports = _dbContext.TArticleSport.Where(x => x.TArticle.Id == tArticle.Id).ToList();
_dbContext.TArticleSport.RemoveRange(ArticleSports.Where(x => !request.Sports.Contains(x.TSportId)));
int selectedSportsCount = _dbContext.TSport.Where(x => request.Sports.Contains(x.Id)).Count();
if (selectedSportsCount != request.Sports.Count)
{
updateArticleResult.Status = false;
updateArticleResult.Message = "Selected Sports are invalid!";
return(Task.FromResult(updateArticleResult));
}
foreach (int SportId in request.Sports.Where(x => !ArticleSports.Any(z => z.TSportId == x)))
{
_dbContext.TArticleSport.Add(new TArticleSport()
{
TArticleId = tArticle.Id,
TSportId = SportId
});
}
_dbContext.SaveChanges();
transaction.Complete();
updateArticleResult.Status = true;
updateArticleResult.Result = new UpdateArticleOutput()
{
Id = tArticle.Id
};
}
}
catch (Exception ex)
{
updateArticleResult.Status = false;
updateArticleResult.Message = ex.Message;
}
return(Task.FromResult(updateArticleResult));
}
public async Task <IActionResult> Update([FromBody] UpdateArticleCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <ActionResult <ArticleDto> > Update(
[FromRoute] int id,
[FromBody] UpdateArticleCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public async Task <IActionResult> Update([FromBody] UpdateArticleCommand updateArticlesCommand)
{
ResultWrapper <UpdateArticleOutput> updateArticlesResult = await _mediator.Send(updateArticlesCommand);
return(Ok(updateArticlesResult));
}
