public async Task <Response <TodoItem> > HandleAsync(CreateTodoItemRequest request)
{
var todoItemEntityResponse = new Response <TodoItemEntity>();
// Query. Apply all validation and modification rules. These rules can only query the database.
await _rulesEngine.ProcessAsync(request, todoItemEntityResponse, _createRulesFactory.Create().ToList());
if (todoItemEntityResponse.HasErrors())
{
return(new Response <TodoItem>(todoItemEntityResponse.Notifications));
}
// Query. Apply all validation and modification rules. These rules can only query the database.
await _rulesEngine.ProcessAsync(request, todoItemEntityResponse, _saveRulesFactory.Create().ToList());
if (todoItemEntityResponse.HasErrors())
{
return(new Response <TodoItem>(todoItemEntityResponse.Notifications));
}
// Command. Save the data.
await _createTodoItemRepository.SaveAsync(todoItemEntityResponse);
LogTodoItemEntityResponse(todoItemEntityResponse);
return(new Response <TodoItem>(todoItemEntityResponse.Notifications, TodoItemMapper.MapToTodoItem(todoItemEntityResponse.Item)));
}
public async Task <IActionResult> CreateTodoItem([FromBody] CreateTodoItemRequest request)
{
var command = _mapper.Map <CreateTodoItemCommand>(request);
var result = await _mediator.Send(command, CancellationToken.None);
var location = Path.Join($"{Request.Scheme}://{Request.Host}", Request.Path, result);
var locationUri = new Uri(location);
return(Created(locationUri, result));
}
public async Task HandleAsyncHasErrorTest(bool createRulesHasError)
{
var request = new CreateTodoItemRequest();
var createRules = RuleFactory.CreateEmptyListOfCreateRules().ToList();
createRules.Add(RuleFactory.CreateMockCreateRule());
var mockCreateRulesFactory = new Mock <IRulesFactory <CreateTodoItemRequest, Response <TodoItemEntity> > >();
mockCreateRulesFactory.Setup(rulesFactory => rulesFactory.Create()).Returns(createRules);
var saveRules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
saveRules.Add(RuleFactory.CreateMockSaveRule());
var mockSaveRulesFactory = new Mock <IRulesFactory <Request <TodoItem>, Response <TodoItemEntity> > >();
mockSaveRulesFactory.Setup(rulesFactory => rulesFactory.Create()).Returns(saveRules);
var errorNotification = Notification.CreateError("1", "error");
var mockRulesEngine = new Mock <IRulesEngine>();
// Setup generic mock setups first and then more specific.
SetupMockProcessAsyncWithSaveRules(mockRulesEngine, request, saveRules,
callbackResponse => ProcessCallBackResponseToAddNotification(!createRulesHasError, callbackResponse, errorNotification));
SetupMockProcessAsyncWithCreateRules(mockRulesEngine, request, createRules,
callbackResponse => ProcessCallBackResponseToAddNotification(createRulesHasError, callbackResponse, errorNotification));
var mockCreateTodoItemRepository = new Mock <ICreateTodoItemRepository>();
var mockLogger = new Mock <ILogger <CreateTodoItemRequestHandler> >();
var handler = new CreateTodoItemRequestHandler(mockRulesEngine.Object, mockCreateRulesFactory.Object, mockSaveRulesFactory.Object, mockCreateTodoItemRepository.Object, mockLogger.Object);
var actualResponse = await handler.HandleAsync(request);
mockCreateRulesFactory.Verify(rulesFactory => rulesFactory.Create(), Times.Once);
mockSaveRulesFactory.Verify(rulesFactory => rulesFactory.Create(),
createRulesHasError ? Times.Never : Times.Once);
mockRulesEngine.Verify(rulesEngine => rulesEngine.ProcessAsync(request, It.IsAny <Response <TodoItemEntity> >(), createRules), Times.Once);
mockRulesEngine.Verify(rulesEngine => rulesEngine.ProcessAsync(request, It.IsAny <Response <TodoItemEntity> >(), saveRules),
createRulesHasError ? Times.Never : Times.Once);
mockCreateRulesFactory.VerifyNoOtherCalls();
mockSaveRulesFactory.VerifyNoOtherCalls();
mockRulesEngine.VerifyNoOtherCalls();
mockCreateTodoItemRepository.VerifyNoOtherCalls();
mockLogger.VerifyNoOtherCalls();
Assert.IsNotNull(actualResponse);
Assert.IsNull(actualResponse.Item);
Assert.AreEqual(1, actualResponse.Notifications.Count);
Assert.AreSame(errorNotification, actualResponse.Notifications.Single());
}
public async Task <IActionResult> Post(int listId, CreateTodoItemRequest request)
{
var authorisationResponse = await _listAuthoriser.IsOwner(listId, _userProfileId);
if (!authorisationResponse.AuthorisationResult)
{
return(NotFound());
}
var todoId = await _todoItemsWriter.Add(request.Title, TodoItemState.Open, listId, _userProfileId);
return(Ok(todoId));
}
protected override Task ProcessRuleAsync(CreateTodoItemRequest request, Response <TodoItemEntity> response)
{
if (request.Item.Id != 0)
{
response.Notifications.Add(TodoItemIdIsNotEmptyRuleNotification());
Fail();
ContinueProcessing = false;
return(Task.CompletedTask);
}
Pass();
return(Task.CompletedTask);
}
public async Task <ActionResult <TodoItem> > Create(CreateTodoItemRequest request)
{
this.logger.LogInformation("Trying to create a new todo item.");
TodoItem todoItem = new TodoItem
{
Description = request.Description,
CreationDate = DateTime.Now,
IsComplete = false,
};
todoItem = await this.todoService.Create(todoItem).ConfigureAwait(false);
this.logger.LogInformation("The new todo item has been created successfully.");
return(todoItem);
}
private static void SetupMockProcessAsyncWithCreateRules(Mock <IRulesEngine> mockRulesEngine, CreateTodoItemRequest request,
IReadOnlyCollection <IBaseRule <CreateTodoItemRequest, Response <TodoItemEntity> > > createRules, Action <Response <TodoItemEntity> > callBackMethod)
{
mockRulesEngine.Setup(rulesEngine => rulesEngine.ProcessAsync(request, It.IsAny <Response <TodoItemEntity> >(), createRules))
.Callback <CreateTodoItemRequest, Response <TodoItemEntity>, IEnumerable <IBaseRule <CreateTodoItemRequest, Response <TodoItemEntity> > > >
((callbackRequest, callbackResponse, callbackRules) =>
{
callBackMethod(callbackResponse);
});
}
public async Task HandleAsyncSuccessTest()
{
var request = new CreateTodoItemRequest();
var expectedResponse = CreateExpectedResponse();
var createRules = RuleFactory.CreateEmptyListOfCreateRules().ToList();
createRules.Add(RuleFactory.CreateMockCreateRule());
var mockCreateRulesFactory = new Mock <IRulesFactory <CreateTodoItemRequest, Response <TodoItemEntity> > >();
mockCreateRulesFactory.Setup(rulesFactory => rulesFactory.Create()).Returns(createRules);
var saveRules = RuleFactory.CreateEmptyListOfSaveRules().ToList();
saveRules.Add(RuleFactory.CreateMockSaveRule());
var mockSaveRulesFactory = new Mock <IRulesFactory <Request <TodoItem>, Response <TodoItemEntity> > >();
mockSaveRulesFactory.Setup(rulesFactory => rulesFactory.Create()).Returns(saveRules);
var mockRulesEngine = new Mock <IRulesEngine>();
// Setup generic mock setups first and then more specific.
SetupMockProcessAsyncWithSaveRules(mockRulesEngine, request, saveRules,
callbackResponse => ProcessCallBackResponseToCloneTodoItem(callbackResponse, expectedResponse));
SetupMockProcessAsyncWithCreateRules(mockRulesEngine, request, createRules,
callbackResponse => ProcessCallBackResponseToCloneTodoItem(callbackResponse, expectedResponse));
mockRulesEngine.Setup(rulesEngine => rulesEngine.ProcessAsync(request, It.IsAny <Response <TodoItemEntity> >(), saveRules))
.Callback <Request <TodoItem>, Response <TodoItemEntity>, IEnumerable <IBaseRule <Request <TodoItem>, Response <TodoItemEntity> > > >
((callbackRequest, callbackResponse, callbackRules) =>
{
callbackResponse.Item = expectedResponse.Clone().Item;
});
var mockCreateTodoItemRepository = new Mock <ICreateTodoItemRepository>();
mockCreateTodoItemRepository.Setup(repository =>
repository.SaveAsync(It.Is <Response <TodoItemEntity> >(response => VerifyTodoItem.AreEqualResponse(expectedResponse, response))));
var mockLogger = new Mock <ILogger <CreateTodoItemRequestHandler> >();
var handler = new CreateTodoItemRequestHandler(mockRulesEngine.Object, mockCreateRulesFactory.Object, mockSaveRulesFactory.Object, mockCreateTodoItemRepository.Object, mockLogger.Object);
var actualResponse = await handler.HandleAsync(request);
mockCreateRulesFactory.Verify(rulesFactory => rulesFactory.Create(), Times.Once);
mockSaveRulesFactory.Verify(rulesFactory => rulesFactory.Create(), Times.Once);
mockRulesEngine.Verify(rulesEngine => rulesEngine.ProcessAsync(request, It.IsAny <Response <TodoItemEntity> >(), createRules), Times.Once);
mockRulesEngine.Verify(rulesEngine => rulesEngine.ProcessAsync(request, It.IsAny <Response <TodoItemEntity> >(), saveRules), Times.Once);
mockCreateTodoItemRepository.Verify(repository =>
repository.SaveAsync(It.Is <Response <TodoItemEntity> >(response => VerifyTodoItem.AreEqualResponse(expectedResponse, response))), Times.Once);
mockCreateRulesFactory.VerifyNoOtherCalls();
mockSaveRulesFactory.VerifyNoOtherCalls();
mockRulesEngine.VerifyNoOtherCalls();
mockCreateTodoItemRepository.VerifyNoOtherCalls();
// Test critical behavior. If the logging here is critical, then verify the calls.
// See examples of ILogger testing in other parts of this app.
mockLogger.VerifyAll();
Assert.IsNotNull(actualResponse);
Assert.IsNotNull(actualResponse.Item);
Assert.IsFalse(actualResponse.HasErrors());
Assert.AreEqual(0, actualResponse.Notifications.Count);
VerifyTodoItem.AssertAreEqualResponse(expectedResponse, actualResponse);
}
public async Task <ActionResult <TodoItemVm> > Create(CreateTodoItemRequest request)
{
var result = await _todoService.AddTodo(request.Name);
return(Ok(result));
}
