public Task <DeleteBoardCommandResult> Delete(DeleteBoardCommand command)
{
Task <DeleteBoardCommandResult> result;
result = _mediator.Send(command);
return(result);
}
public async Task Handle_BoardIdNotExists_ThrowsNotFoundApplicationException()
{
var dbName = $"{nameof(DeleteBoardCommandHandlerTests)}_{nameof(Handle_BoardIdNotExists_ThrowsNotFoundApplicationException)}";
using var context = TestApplicationDbContext.Create(dbName);
var handler = new DeleteBoardCommandHandler(context);
var request = new DeleteBoardCommand(1);
var cancellationToken = new CancellationToken();
Task <Unit> action() => handler.Handle(request, cancellationToken);
await Assert.ThrowsAsync <NotFoundApplicationException>(action);
}
public ActionResult <bool> Delete(BoardDeleteInput input)
{
DeleteBoardCommand command = _mapper.Map <BoardDeleteInput, DeleteBoardCommand>(input);
Task <DeleteBoardCommandResult> result = _boardService.Delete(command);
if (result.Result.ResultObject.Success)
{
return(Ok(result.Result.ResultObject));
}
else
{
return(BadRequest(result));
}
}
public async Task <IActionResult> DeleteBoard(Guid boardGuidToDelete)
{
try
{
DeleteBoardCommand deleteBoardCommand = new DeleteBoardCommand(boardGuidToDelete);
await mediator.Send(deleteBoardCommand);
return(NoContent());
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task Delete_StateUnderTest_ExpectedBehavior()
{
// Arrange
var service = this.CreateService();
DeleteBoardCommand command = null;
// Act
var result = await service.Delete(
command);
// Assert
Assert.True(false);
this.mockRepository.VerifyAll();
}
public async Task <MutationResult> DeleteBoard(string id)
{
var request = new DeleteBoardCommand
{
BoardId = id
};
try
{
await processor.Run(request);
return(MutationResult.Success());
} catch (Exception e) {
return(MutationResult.Error(e));
}
}
public async Task Handle_BoardIdExists_DeletesBoard()
{
var dbName = $"{nameof(DeleteBoardCommandHandlerTests)}_{nameof(Handle_BoardIdExists_DeletesBoard)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var handler = new DeleteBoardCommandHandler(context);
var request = new DeleteBoardCommand(1);
await handler.Handle(request, cancellationToken);
var boardFromDb = await context.Boards.FirstOrDefaultAsync(b => b.Id == 1);
Assert.Null(boardFromDb);
}
public async Task <DeleteBoardByIdResponse> Handle(DeleteBoardByIdRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new DeleteBoardByIdResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var query = new GetBoardQuery()
{
Id = request.BoardId
};
var board = await queryExecutor.Execute(query);
if (board == null)
{
return(new DeleteBoardByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var command = new DeleteBoardCommand()
{
Parameter = board
};
var deletedBoard = await commandExecutor.Execute(command);
return(new DeleteBoardByIdResponse
{
Data = deletedBoard
});
}
public Task DeleteBoard(int playerId, CancellationToken cancellationToken)
{
var command = new DeleteBoardCommand(playerId);
return(_mediator.Send(command, cancellationToken));
}
public async Task <ActionResult <BoardsViewModel> > Delete([FromBody] DeleteBoardCommand command)
{
return(Ok(await Mediator.Send(command)));
}
