public void UpdateTaskTest()
{
var testGuid = Guid.NewGuid();
var request = new UpdateTaskRequest(testGuid)
{
TaskProperties = new TaskEditDTO {
Name = "test",
Time = DateTime.Now,
UserId = Guid.NewGuid()
}
};
var expectedResonse = new UpdateTaskResponse {
Exception = null
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.UpdateTask(request)).Returns(expectedResonse);
var mockLogger = new Mock <ILoggingService>();
var mockEmail = new Mock <IEmailService>();
var mockConfig = new Mock <IAppConfig <IServiceConfigOptions> >();
var service = new EnrichedTaskService(mockService.Object, mockLogger.Object, mockEmail.Object,
mockConfig.Object);
var response = service.UpdateTask(request);
Assert.IsNull(response.Exception);
Assert.AreEqual(expectedResonse.Exception, response.Exception);
mockService.Verify(x => x.UpdateTask(request), Times.Once);
}
public UpdateTaskResponse UpdateTask(UpdateTaskRequest request)
{
var response = new UpdateTaskResponse();
try
{
var existingTask = _taskRepository.FindBy(request.Id);
if (existingTask != null)
{
_taskMapper.PopulateDomainObject(existingTask, request.TaskProperties);
ThrowExceptionIfTaskIsInvalid(existingTask);
_taskRepository.Update(existingTask);
_uow.Commit();
response.Result = true;
return(response);
}
response.Exception = GetStandardTaskNotFoundException();
return(response);
}
catch (Exception ex)
{
response.Exception = ex;
return(response);
}
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
UpdateTaskResponse response = new UpdateTaskResponse();
return(response);
}
public static UpdateTaskResponse Unmarshall(UnmarshallerContext _ctx)
{
UpdateTaskResponse updateTaskResponse = new UpdateTaskResponse();
updateTaskResponse.HttpResponse = _ctx.HttpResponse;
updateTaskResponse.RequestId = _ctx.StringValue("UpdateTask.RequestId");
return(updateTaskResponse);
}
public HttpResponseMessage UpdateTask(UpdateTaskRequest request, int todolistid, int taskid)
{
var response = new UpdateTaskResponse();
if (_sessionManager.IsActive(request.SessionId))
{
_taskManager.AddTaskToDatabase(request.Task);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Conflict, response));
}
}
public void UpdateTaskInvalidTest()
{
var testGuid = Guid.NewGuid();
var request = new UpdateTaskRequest(testGuid)
{
TaskProperties = new TaskEditDTO {
Time = DateTime.Now,
UserId = Guid.NewGuid()
}
};
var expectedResonse = new UpdateTaskResponse {
Exception = new ValidationException("invalid")
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.UpdateTask(request)).Returns(expectedResonse);
var mockLogger = new Mock <ILoggingService>();
var mockEmail = new Mock <IEmailService>();
mockEmail.Setup(x => x.SendEmail(It.IsAny <EmailArguments>()));
var mockConfigOptions = new Mock <IServiceConfigOptions>();
mockConfigOptions.Setup(x => x.AdminEmail).Returns("test");
mockConfigOptions.Setup(x => x.ErrorEmailSubject).Returns("test");
mockConfigOptions.Setup(x => x.SmtpServer).Returns("test");
mockConfigOptions.Setup(x => x.SystemEmail).Returns("test");
var mockConfig = new Mock <IAppConfig <IServiceConfigOptions> >();
mockConfig.Setup(x => x.Options).Returns(mockConfigOptions.Object);
var service = new EnrichedTaskService(mockService.Object, mockLogger.Object, mockEmail.Object,
mockConfig.Object);
var response = service.UpdateTask(request);
Assert.IsNotNull(response.Exception);
mockLogger.Verify(x => x.LogError(It.IsAny <object>(), "invalid", It.IsAny <ValidationException>()),
Times.Once);
mockEmail.Verify(x => x.SendEmail(It.IsAny <EmailArguments>()), Times.Once);
}
public void PutNotFoundTest()
{
var testGuid = Guid.NewGuid();
var input = new TaskDTO {
Id = testGuid,
Name = "test",
Time = DateTime.Now,
UserId = Guid.NewGuid(),
UserFirstName = "test",
UserLastName = "test"
};
var expected = new UpdateTaskResponse {
Result = false,
Exception = new ResourceNotFoundException("task")
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.UpdateTask(It.IsAny <UpdateTaskRequest>())).Returns(expected);
var mockRespoonseBuilder = new Mock <IHttpResponseBuilder>();
var controller = new TaskController(mockService.Object, mockRespoonseBuilder.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
mockRespoonseBuilder.Setup(x => x.BuildResponse(It.IsAny <HttpRequestMessage>(), expected))
.Returns(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(expected.Exception.Message)
});
var response = controller.Put(input);
bool result;
response.TryGetContentValue(out result);
Assert.IsFalse(result);
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
mockService.Verify(x => x.UpdateTask(It.IsAny <UpdateTaskRequest>()), Times.Once);
}
public void PutTest()
{
var testGuid = Guid.NewGuid();
var input = new TaskDTO {
Id = testGuid,
Name = "test",
Time = DateTime.Now,
UserId = Guid.NewGuid(),
UserFirstName = "test",
UserLastName = "test"
};
var expected = new UpdateTaskResponse {
Result = true
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.UpdateTask(It.IsAny <UpdateTaskRequest>())).Returns(expected);
var mockRespoonseBuilder = new Mock <IHttpResponseBuilder>();
var controller = new TaskController(mockService.Object, mockRespoonseBuilder.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
mockRespoonseBuilder.Setup(x => x.BuildResponse(controller.Request, expected))
.Returns(controller.Request.CreateResponse(HttpStatusCode.OK, expected.Result));
var response = controller.Put(input);
bool result;
response.TryGetContentValue(out result);
Assert.IsTrue(result);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
mockService.Verify(x => x.UpdateTask(It.IsAny <UpdateTaskRequest>()), Times.Once);
}
public HttpResponseMessage Put([FromBody] TaskDTO task)
{
var request = new UpdateTaskRequest(task.Id)
{
TaskProperties = task
};
var response = new UpdateTaskResponse();
try
{
response = _taskService.UpdateTask(request);
}
catch (Exception ex)
{
response.Exception = ex;
}
return(_responseBuilder.BuildResponse(Request, response));
}
public Task Handle(UpdateTaskResponse message, IMessageHandlerContext context)
{
Data.TaskUpdatedResponse = message;
MarkAsComplete();
return(Task.CompletedTask);
}
