/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
DeleteTaskResponse response = new DeleteTaskResponse();
return(response);
}
public void DeleteTest()
{
var testGuid = Guid.NewGuid();
var expected = new DeleteTaskResponse {
Result = true
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.DeleteTask(It.IsAny <DeleteTaskRequest>())).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.Delete(testGuid);
bool result;
response.TryGetContentValue(out result);
Assert.IsTrue(result);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
mockService.Verify(x => x.DeleteTask(It.IsAny <DeleteTaskRequest>()), Times.Once);
}
public DeleteTaskResponse DeleteTask(DeleteTaskRequest request)
{
var response = new DeleteTaskResponse();
try
{
var task = _taskRepository.FindBy(request.Id);
if (task != null)
{
_taskRepository.Delete(task);
_uow.Commit();
response.Result = true;
return(response);
}
response.Exception = GetStandardTaskNotFoundException();
return(response);
}
catch (Exception ex)
{
response.Exception = ex;
return(response);
}
}
public void DeleteTaskTest()
{
var testGuid = Guid.NewGuid();
var request = new DeleteTaskRequest(testGuid);
var expectedResonse = new DeleteTaskResponse {
Exception = null
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.DeleteTask(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.DeleteTask(request);
Assert.IsNull(response.Exception);
Assert.AreEqual(expectedResonse.Exception, response.Exception);
mockService.Verify(x => x.DeleteTask(request), Times.Once);
}
public void RemoveBatchTaskParametersTest()
{
// Setup cmdlet without the required parameters
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
// Setup cmdlet to skip confirmation popup
cmdlet.Force = true;
commandRuntimeMock.Setup(f => f.ShouldProcess(It.IsAny<string>(), It.IsAny<string>())).Returns(true);
Assert.Throws<ArgumentNullException>(() => cmdlet.ExecuteCmdlet());
cmdlet.WorkItemName = "testWorkItem";
cmdlet.JobName = "job-0000000001";
cmdlet.Name = "testTask";
// Don't go to the service on a DeleteJob call
YieldInjectionInterceptor interceptor = new YieldInjectionInterceptor((opContext, request) =>
{
if (request is DeleteTaskRequest)
{
DeleteTaskResponse response = new DeleteTaskResponse();
Task<object> task = Task<object>.Factory.StartNew(() => { return response; });
return task;
}
return null;
});
cmdlet.AdditionalBehaviors = new List<BatchClientBehavior>() { interceptor };
// Verify no exceptions when required parameters are set
cmdlet.ExecuteCmdlet();
}
public DeleteTaskResponse DeleteTask(DeleteTaskRequest task, UnitOfWork context)
{
var response = new DeleteTaskResponse();
var taskDb = context.Tasks.GetItem(task.Id);
response.Count = context.Tasks.RemoveItem(taskDb);
return(response);
}
public HttpResponseMessage DeleteTask(DeleteTaskRequest request, int todolistid, int taskid)
{
var response = new DeleteTaskResponse();
if (_sessionManager.IsActive(request.SessionId))
{
_taskManager.DeleteTask(taskid);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Conflict, response));
}
}
public HttpResponseMessage Delete(Guid id)
{
var request = new DeleteTaskRequest(id);
var response = new DeleteTaskResponse();
try
{
response = _taskService.DeleteTask(request);
}
catch (Exception ex)
{
response.Exception = ex;
}
return(_responseBuilder.BuildResponse(Request, response));
}
public void DeleteTaskInvalidTest()
{
var testGuid = Guid.NewGuid();
var request = new DeleteTaskRequest(testGuid);
var expectedResonse = new DeleteTaskResponse {
Exception = new ValidationException("invalid")
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.DeleteTask(request)).Returns(expectedResonse);
var mockLogger = new Mock <ILoggingService>();
var mockEmail = new Mock <IEmailService>();
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.DeleteTask(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 DeleteTaskResponse Delete(DeleteTaskRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
DeleteTaskResponse response = new DeleteTaskResponse();
var record = _taskItemRepository.GetById(request.Id);
if (record == null)
{
response.Code = ResponseCode.NotFound;
response.Message = "Record not found.";
return(response);
}
_taskItemRepository.Delete(record);
return(response);
}
public void DeleteNotFoundTest()
{
var testGuid = Guid.NewGuid();
var expected = new DeleteTaskResponse {
Result = false,
Exception = new ResourceNotFoundException("task")
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.DeleteTask(It.IsAny <DeleteTaskRequest>())).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(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(expected.Exception.Message)
});
var response = controller.Delete(testGuid);
bool result;
response.TryGetContentValue(out result);
Assert.IsFalse(result);
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
mockService.Verify(x => x.DeleteTask(It.IsAny <DeleteTaskRequest>()), Times.Once);
}
public void RemoveBatchTaskParametersTest()
{
// Setup cmdlet without the required parameters
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
// Setup cmdlet to skip confirmation popup
cmdlet.Force = true;
commandRuntimeMock.Setup(f => f.ShouldProcess(It.IsAny <string>(), It.IsAny <string>())).Returns(true);
Assert.Throws <ArgumentNullException>(() => cmdlet.ExecuteCmdlet());
cmdlet.WorkItemName = "testWorkItem";
cmdlet.JobName = "job-0000000001";
cmdlet.Name = "testTask";
// Don't go to the service on a DeleteJob call
YieldInjectionInterceptor interceptor = new YieldInjectionInterceptor((opContext, request) =>
{
if (request is DeleteTaskRequest)
{
DeleteTaskResponse response = new DeleteTaskResponse();
Task <object> task = Task <object> .Factory.StartNew(() => { return(response); });
return(task);
}
return(null);
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>()
{
interceptor
};
// Verify no exceptions when required parameters are set
cmdlet.ExecuteCmdlet();
}
