public async Task GivenSlugOfExistingArticle_DeletesArticleWithTags()
{
// Arrange
var user = new UserProfile(Guid.NewGuid().ToString(), "*****@*****.**", "username");
var article = new Article("test title", "test", "test", new DateTime(1111, 1, 1), user,
new List <Tag> {
new Tag("test tag")
});
Context.Articles.Add(article);
await Context.SaveChangesAsync();
var currentUser = Mock.Of <ICurrentUserService>(s => s.UserId == user.Id);
var command = new DeleteArticleCommand {
Slug = article.Slug
};
var sut = new DeleteArticleCommand.Handler(Context, currentUser);
// Act
await sut.Handle(command, CancellationToken.None);
var existingArticle = await Context.Articles
.SingleOrDefaultAsync(a => a.Id == article.Id);
var tags = await Context.ArticleTags.Where(a => a.ArticleId == article.Id).ToListAsync();
// Assert
existingArticle.Should().BeNull();
tags.Should().BeEmpty();
}
public async Task <ResultWrapper <DeleteArticleOutput> > Handle(DeleteArticleCommand request, CancellationToken cancellationToken)
{
ResultWrapper <DeleteArticleOutput> result = new ResultWrapper <DeleteArticleOutput>();
try
{
var tData = await _dbContext.TArticle.FirstOrDefaultAsync(x => x.Id == request.Id);
if (tData == null)
{
result.Status = false;
result.Message = "Article doesn't exists";
return(result);
}
if (tData.TArticleSports != null && tData.TArticleSports.Any())
{
_dbContext.TArticleSport.RemoveRange(tData.TArticleSports);
}
_dbContext.TArticle.Remove(tData);
await _dbContext.SaveChangesAsync();
result.Status = true;
result.Result = new DeleteArticleOutput()
{
};
}
catch (Exception ex)
{
result.Status = false;
result.Message = ex.Message;
}
return(result);
}
public DeleteArticleCommandTest()
{
this.mockArticleService = new Mock <IArticleService>();
this.deleteArticleCommandHandler = new DeleteArticleCommandHandler(this.mockArticleService.Object);
this.deleteArticleCommand = new DeleteArticleCommand(TestSlug);
}
public DeleteArticleCommandHandlerTests()
{
_articleManagementService = Mock.Of <IArticleManagementService>();
_deleteArticleCommandHandler = new DeleteArticleCommandHandler(_articleManagementService);
_deleteArticleCommand = new DeleteArticleCommand(SomeSlug);
}
public async Task DeleteArticle(DeleteArticleCommand command)
{
await CheckIfUserCanEditorDeleteArticle(command.UserId, command.ArticleId);
PrepareArticleToRemove();
await RemoveArticle();
}
public async Task <IActionResult> DeleteArticle(int id)
{
var command = new DeleteArticleCommand(id);
var response = await _mediator.Send(command);
return(response.ToActionResult());
}
void AndGivenCommandPrepared()
{
_command = new DeleteArticleCommand
{
ArticleId = _articleId
};
}
public async Task <IActionResult> Delete(
[FromRoute] Guid id,
CancellationToken ct = default)
{
var command = new DeleteArticleCommand(id);
await Mediator.Send(command, ct);
return(NoContent());
}
public async Task <ApiResult> DeleteArticleAsync([FromBody] DeleteArticleCommand command)
{
if (!ModelState.IsValid)
{
return(InValidModelsError());
}
_log.LogInformation("执行DeleteArticleAsync...控制器方法");
return(await _mediator.Send(command));
}
public void ShouldRequireValidArticleId()
{
//arrange
var command = new DeleteArticleCommand {
Id = Guid.NewGuid()
};
//assert
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <NotFoundException>();
}
public async Task <IActionResult> DeleteArticles(DeleteArticleCommand model)
{
FirebaseUser user = HttpContext.GetFirebaseUser();
model.FireBaseId = user.UserId;
ResultWrapper <DeleteArticleOutput> result = new ResultWrapper <DeleteArticleOutput>();
result = await _mediator.Send(model);
return(Ok(result));
}
public async Task <IActionResult> Delete(Guid id)
{
var command = new DeleteArticleCommand
{
ArticleId = id
};
await _mediator.Send(command);
return(NoContent());
}
public void ShouldNotCallHandleIfArticleNotExist()
{
dbSetArticle.Setup(x => x.FindAsync(id)).Returns(null);
context.Setup(x => x.Articles).Returns(dbSetArticle.Object);
DeleteArticleCommandHandler deleteArticleCommandHandler = new DeleteArticleCommandHandler(context.Object, stringLocalizer.Object);
DeleteArticleCommand deleteArticleCommand = new DeleteArticleCommand(id);
Func <Task> act = async() => await deleteArticleCommandHandler.Handle(deleteArticleCommand, new CancellationToken());
act.Should().Throw <NotFoundException>();
}
public async Task GivenValidDeleteArticleRequest_WhenTheArticleExistsAndIsOwnedByTheUser_ReturnsSuccessfulResponse()
{
// Arrange
var deleteArticleCommand = new DeleteArticleCommand("how-to-train-your-dragon");
await ContentHelper.GetRequestWithAuthorization(Client);
// Act
var response = await Client.DeleteAsync($"{ArticlesEndpoint}/{deleteArticleCommand.Slug}");
// Assert
response.EnsureSuccessStatusCode();
}
public async Task GivenTheRequestIsValid_WhenTheUserIsTheAuthorOfArticle_DeletesArticleFromDbContext()
{
// Arrange
var deleteArticleCommand = new DeleteArticleCommand("Why Beer is God's Gift to the World".ToSlug());
// Act
var request = new DeleteArticleCommandHandler(_logger, Context, CurrentUserContext);
var result = await request.Handle(deleteArticleCommand, CancellationToken.None);
// Assert, verify removal from the database
result.ShouldNotBeNull();
Context.Articles.FirstOrDefault(a => a.Slug == "Why Beer is God's Gift to the World".ToSlug())?.ShouldBeNull();
}
public async Task Delete_ExistingObject_ObjectIsDeleted()
{
//Arrange
var id = 1;
var deleteArticleCommand = new DeleteArticleCommand(_unitOfWork);
var countBefore = TestContext.Articles.Count();
//Act
var result = await deleteArticleCommand.Execute(id);
//Assert
Assert.That(TestContext.Articles.Count(), Is.EqualTo(countBefore - 1));
Assert.That(result, Is.EqualTo(true));
}
public void TestDeleteArticleCommand_NotFound()
{
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 deleteCommand = new DeleteArticleCommand()
{
Id = Guid.NewGuid()
};
var handler = new DeleteArticleCommand.Handler(articleRepo.Object, mediator.Object);
Assert.ThrowsAsync <NotFoundException>(() => handler.Handle(deleteCommand, new CancellationToken()));
}
public async Task ShouldCallHandle()
{
dbSetArticle.Setup(x => x.FindAsync(id)).Returns(new ValueTask <Article>(Task.FromResult(new Article {
Id = id
})));
context.Setup(x => x.Articles).Returns(dbSetArticle.Object);
context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));
DeleteArticleCommandHandler deleteArticleCommandHandler = new DeleteArticleCommandHandler(context.Object, stringLocalizer.Object);
DeleteArticleCommand deleteArticleCommand = new DeleteArticleCommand(id);
var result = await deleteArticleCommandHandler.Handle(deleteArticleCommand, new CancellationToken());
result.Should().Be(Unit.Value);
}
public async Task Delete_ExistingObject_CorrectCallsPerformed()
{
//Arrange
var id = 1;
var deleteArticleCommand = new DeleteArticleCommand(_unitOfWorkMock.Object);
var countBefore = TestContext.Articles.Count();
//Act
var result = await deleteArticleCommand.Execute(id);
//Assert
_articleRepositoryMock.Verify(r => r.GetArticleByIdAsync(It.IsAny <int>()), Times.Once);
_articleRepositoryMock.Verify(r => r.Delete(It.IsAny <Article>()), Times.Once);
_unitOfWorkMock.Verify(u => u.Commit(), Times.Once);
}
public void ShouldNotCallHandleIfNotSavedChanges()
{
dbSetArticle.Setup(x => x.FindAsync(id)).Returns(new ValueTask <Article>(Task.FromResult(new Article {
Id = id
})));
context.Setup(x => x.Articles).Returns(dbSetArticle.Object);
context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(0));
DeleteArticleCommandHandler deleteArticleCommandHandler = new DeleteArticleCommandHandler(context.Object, stringLocalizer.Object);
DeleteArticleCommand deleteArticleCommand = new DeleteArticleCommand(id);
Func <Task> act = async() => await deleteArticleCommandHandler.Handle(deleteArticleCommand, new CancellationToken());
act.Should().Throw <RestException>();
}
public async Task Delete_NonExistingObject_ObjectIsNotDeleted()
{
//Arrange
var id = 1;
var deleteArticleCommand = new DeleteArticleCommand(_unitOfWorkMock.Object);
_unitOfWorkMock.Setup(uow => uow.Commit()).Returns(Task.FromResult(false));
//Act
var result = await deleteArticleCommand.Execute(id);
//Assert
_articleRepositoryMock.Verify(r => r.GetArticleByIdAsync(It.IsAny <int>()), Times.Once);
_articleRepositoryMock.Verify(r => r.Delete(It.IsAny <Article>()), Times.Once);
Assert.That(result, Is.EqualTo(false));
}
public async Task GivenTheRequestIsValid_WhenTheArticleDoesNotExist_ThrowsApiExceptionForNotFound()
{
// Arrange
var deleteArticleCommand = new DeleteArticleCommand("How to train your dragon".ToSlug());
// Act
var request = new DeleteArticleCommandHandler(_logger, Context, CurrentUserContext);
// Assert
await Should.ThrowAsync <ConduitApiException>(async() =>
{
await request.Handle(deleteArticleCommand, CancellationToken.None);
});
Context.Articles.FirstOrDefault(a => a.Slug == "How to train your dragon".ToSlug()).ShouldNotBeNull();
}
public async Task GivenValidDeleteArticleRequest_WhenTheArticleDoesNotExist_ReturnsErrorViewModelForNotFound()
{
// Arrange
var deleteArticleCommand = new DeleteArticleCommand("this-is-a-fake-article");
await ContentHelper.GetRequestWithAuthorization(Client);
// Act
var response = await Client.DeleteAsync($"{ArticlesEndpoint}/{deleteArticleCommand.Slug}");
var responseContent = await ContentHelper.GetResponseContent <ErrorViewModel>(response);
// Assert
response.StatusCode.ShouldBe(HttpStatusCode.NotFound);
responseContent.ShouldNotBeNull();
responseContent.ShouldBeOfType <ErrorViewModel>();
responseContent.Errors.ShouldNotBeNull();
}
public async Task GivenSlugOfNonExistingArticle_ThrowsEntityNotFoundException()
{
// Arrange
var currentUser = Mock.Of <ICurrentUserService>();
var command = new DeleteArticleCommand {
Slug = "some slug"
};
var sut = new DeleteArticleCommand.Handler(Context, currentUser);
// Act
var action = new Func <Task <Unit> >(() => sut.Handle(command, CancellationToken.None));
// Assert
await action.Should().ThrowAsync <EntityNotFoundException <Article> >();
}
public async Task GivenValidDeleteArticleRequest_WhenTheArticleExistsAndIsNotOwnedByTheUser_ReturnsErrorViewModelForUnauthorized()
{
// Arrange
var deleteArticleCommand = new DeleteArticleCommand("how-to-train-your-dragon");
await ContentHelper.GetRequestWithAuthorization(Client, IntegrationTestConstants.SecondaryUser);
// Act
var response = await Client.DeleteAsync($"{ArticlesEndpoint}/{deleteArticleCommand.Slug}");
var responseContent = await ContentHelper.GetResponseContent <ErrorViewModel>(response);
// Assert
response.StatusCode.ShouldBe(HttpStatusCode.Unauthorized);
responseContent.ShouldNotBeNull();
responseContent.ShouldBeOfType <ErrorViewModel>();
responseContent.Errors.ShouldNotBeNull();
}
/// <summary>
/// 删除文章
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task <Unit> Handle(DeleteArticleCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
NotifyValidationErrors(request);
return(Unit.Task);
}
_articleRepository.DeleteById(request.Id);
if (Commit())
{
//提交成功，发布领域事件
_bus.RaiseEvent(new DomainNotification(nameof(DeleteArticleCommand), "删除成功"));
}
else
{
_bus.RaiseEvent(new DomainNotification(nameof(DeleteArticleCommand), "删除失败，请稍后再试"));
}
return(Unit.Task);
}
public async Task DeleteArticleCommandTestAsync(string identityUserId, int articleId, DeleteArticleResponse result)
{
DeleteArticleCommand request = new DeleteArticleCommand
{
Id = articleId,
IdentityUserId = identityUserId,
};
DeleteArticleCommandHandler handler = new DeleteArticleCommandHandler(_deleteFixture.Context);
var expectedResult = await handler.Handle(request, new CancellationToken());
Assert.Equal(expectedResult.IsSuccessful, result.IsSuccessful);
if (expectedResult.IsSuccessful)
{
Article deletedArticle = _deleteFixture.Context.Articles.Find(expectedResult.Id);
Assert.Null(deletedArticle);
Assert.Equal(expectedResult.ViewRole, result.ViewRole);
Assert.Equal(expectedResult.EditRole, result.EditRole);
}
Assert.Equal(expectedResult.Message, result.Message);
}
public async Task ShouldDeleteArticle()
{
await Helper.EnsureUserIsCreatedAndSetInDatabaseContext();
var articleDto = await Helper.CreateDefaultArticle_ReturnDefaultArticleDto();
var originalArticleCount = await SliceFixture.ExecuteDbContextAsync(db => db.Articles.CountAsync());
Assert.AreEqual(1, originalArticleCount);
var deleteCommand = new DeleteArticleCommand(articleDto.Slug);
await SliceFixture.ExecuteDbContextAsync(async (ctx, mediator) =>
{
await mediator.Send(deleteCommand);
});
var actualArticleCount = await SliceFixture.ExecuteDbContextAsync(db => db.Articles.CountAsync());
Assert.AreEqual(0, actualArticleCount);
}
public async Task GivenUserThatIsNotAuthor_ThrowsBadRequestException()
{
// Arrange
var article = new Article("test title", "test", "test", new DateTime(1111, 1, 1),
new UserProfile(Guid.NewGuid().ToString(), "*****@*****.**", "username"));
Context.Articles.Add(article);
await Context.SaveChangesAsync();
var currentUser = Mock.Of <ICurrentUserService>();
var command = new DeleteArticleCommand {
Slug = article.Slug
};
var sut = new DeleteArticleCommand.Handler(Context, currentUser);
// Act
var action = new Func <Task <Unit> >(() => sut.Handle(command, CancellationToken.None));
// Assert
await action.Should().ThrowAsync <BadRequestException>();
}
public async Task <IActionResult> DeleteArticle([FromBody] DeleteArticleCommand command)
{
var actionName = ControllerContext.ActionDescriptor.ActionName;
try
{
_logger.LogMessage(actionName, JsonConvert.SerializeObject(command), LogEventLevel.Information);
return(Ok(await Mediator.Send(command)));
}
catch (ValidationException exception)
{
return(StatusCode(badRequestErrorCode, JsonConvert.SerializeObject(exception.Failures)));
}
catch (DbUpdateConcurrencyException exception)
{
_logger.LogException(exception, actionName, JsonConvert.SerializeObject(command) + " " + JsonConvert.SerializeObject(command));
return(StatusCode(notFoundErrorCode, _configuration.DisplayObjectNotFoundErrorMessage));
}
catch (Exception exception)
{
_logger.LogException(exception, actionName, JsonConvert.SerializeObject(command) + " " + JsonConvert.SerializeObject(command));
return(StatusCode(internalServerErrorCode, _configuration.ErrorMessage));
}
}
