public async Task ModTest(string taskDescription, int priority, string startDateStr, string endDateStr)
{
DateTime startDate = DateTime.Parse(startDateStr);
DateTime endDate = DateTime.Parse(endDateStr);
var taskMod = new TaskMod
{
EndDate = endDate,
StartDate = startDate,
Priority = priority,
TaskDescription = taskDescription
};
var resulTasks = new Tasks
{
EndDate = endDate,
Priortiy = priority,
TaskDeatails = taskDescription,
Status = 1,
StartDate = startDate,
TaskId = 1
};
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(map => map.Map <Tasks>(It.IsAny <TaskMod>())).Returns(resulTasks);
var mockTaskRepo = new Mock <ITaskRepo>();
mockTaskRepo.Setup(tskService => tskService.EditTask(It.IsAny <Tasks>()))
.Returns(Task.FromResult <bool>(true));
var taskService = new TasksService(mockMapper.Object, mockTaskRepo.Object, logger);
var result = await taskService.ModifyTask(taskMod);
Assert.True(result);
}
public async Task <bool> ModifyTask(TaskMod taskMod)
{
var validationContext = new System.ComponentModel.DataAnnotations.ValidationContext(taskMod);
var validationResults = new List <ValidationResult>();
if (Validator.TryValidateObject(taskMod, validationContext, validationResults))
{
var tasks = mapper.Map <Tasks>(taskMod);
return(await taskRepo.EditTask(tasks));
}
return(false);
}
public async Task<Tuple<bool, string>> EditTask(TaskMod projTask)
{
if ((projTask.EndDate > DateTime.MinValue) && (projTask.StartDate > DateTime.MinValue)
&& (projTask.StartDate > projTask.EndDate))
return new Tuple<bool, string>(false, "start date greater than end date");
var validationContext = new System.ComponentModel.DataAnnotations.ValidationContext(projTask);
var validationResults = new List<ValidationResult>();
if (Validator.TryValidateObject(projTask, validationContext, validationResults))
{
var taskDO = mapper.Map<ProjTask>(projTask);
return await projectTaskRepo.EditTask(projTask.ProjectId, taskDO);
}
return new Tuple<bool, string>(false, "validation failures");
}
public void GetterSetterTest()
{
var taskMod = new TaskMod
{
EndDate = DateTime.Today.AddDays(1),
StartDate = DateTime.Today,
ParentTaskId = 1,
Priority = 1,
TaskDescription = "task1",
TaskId = 0
};
Assert.Equal(DateTime.Today.AddDays(1), taskMod.EndDate);
Assert.Equal(DateTime.Today, taskMod.StartDate);
Assert.Equal(1, taskMod.ParentTaskId);
Assert.Equal(1, taskMod.Priority);
Assert.Equal("task1", taskMod.TaskDescription);
Assert.Equal(0, taskMod.TaskId);
}
public async Task PutTest(string taskDescription, int priority, string startDateStr, string endDateStr)
{
DateTime startDate = DateTime.Parse(startDateStr);
DateTime endDate = DateTime.Parse(endDateStr);
var taskMod = new TaskMod
{
EndDate = endDate,
StartDate = startDate,
Priority = priority,
TaskDescription = taskDescription
};
var mockService = new Mock <ITaskService>();
mockService.Setup(service => service.ModifyTask(It.IsAny <TaskMod>()))
.Returns(Task.FromResult(true));
var controller = new TaskController(mockService.Object, logger);
var result = (await controller.Put(taskMod)).Result as AcceptedResult;
Assert.NotNull(result);
Assert.Equal(202, result.StatusCode);
}
public async Task <ActionResult <bool> > Put([FromBody] TaskMod taskMod)
{
if (taskMod == null)
{
ModelState.AddModelError("ParameterEmpty", "Input parameter are all empty");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await taskService.ModifyTask(taskMod);
if (result)
{
return(Accepted(result));
}
else
{
return(StatusCode(500, "Modification failed"));
}
}
public async Task <ActionResult <bool> > EditTask([FromBody] TaskMod taskMod)
{
if (taskMod == null)
{
ModelState.AddModelError("ParameterEmpty", "Input parameter are all empty");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await projService.EditTask(taskMod);
if (result.Item1)
{
return(Accepted());
}
else
{
return(StatusCode(500, "Unable to edit task"));
}
}
public void GetterSetterTest()
{
var takMod = new TaskMod
{
EndDate = DateTime.Today.AddDays(2),
ParentTaskId = "P/1-1",
Priority = 1,
ProjectId = "P/1",
StartDate = DateTime.Today,
TaskDescription = "Task1",
TaskOwnerId = "Usr/1",
TaskId = "P/1-2"
};
Assert.Equal(DateTime.Today.AddDays(2), takMod.EndDate);
Assert.Equal("P/1-1", takMod.ParentTaskId);
Assert.Equal(1, takMod.Priority);
Assert.Equal(DateTime.Today, takMod.StartDate);
Assert.Equal("Task1", takMod.TaskDescription);
Assert.Equal("Usr/1", takMod.TaskOwnerId);
Assert.Equal("P/1-2", takMod.TaskId);
}
public async Task EditTaskTest()
{
var projTasks = new ProjTask
{
ParentTaskId = "",
EndDate = DateTime.Today.AddDays(2),
Priority = 1,
Start = DateTime.Today,
Name = "ParentTask",
TaskOwnerId = "Usr/2",
Status = 0
};
var taskMod = new TaskMod
{
ParentTaskId = "",
EndDate = DateTime.Today.AddDays(2),
Priority = 1,
StartDate = DateTime.Today,
TaskDescription = "ParentTask",
TaskOwnerId = "Usr/2",
ProjectId = "P/1",
TaskId = "P/1-1"
};
var mockProjTaskRepo = new Mock <IProjectTaskRepo>();
mockProjTaskRepo.Setup(repo => repo.EditTask(It.IsAny <string>(), It.IsAny <ProjTask>()))
.Returns(Task.FromResult(new Tuple <bool, string>(true, "P/1-1")));
var mockLogger = createProjServiceLogger();
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(map => map.Map <ProjTask>(It.IsAny <TaskMod>())).Returns(projTasks);
var projectTaskService = new ProjTaskService(mockProjTaskRepo.Object, mockLogger, mockMapper.Object);
var result = await projectTaskService.EditTask(taskMod);
Assert.True(result.Item1);
Assert.Equal("P/1-1", result.Item2);
}
public async Task EditTaskTest()
{
var taskMod = new TaskMod
{
EndDate = DateTime.Today.AddDays(2),
ParentTaskId = "P/1-1",
Priority = 1,
ProjectId = "P/1",
StartDate = DateTime.Today,
TaskDescription = "Task1",
TaskId = "P/1-2",
TaskOwnerId = "Usr/1"
};
var projectService = new Mock <IProjTaskService>();
projectService.Setup(ser => ser.EditTask(It.IsAny <TaskMod>()))
.Returns(Task.FromResult(new Tuple <bool, string>(true, "P/1-1")));
var logger = createLogger();
var projectController = new ProjectController(projectService.Object, logger);
var actionResult = (await projectController.EditTask(taskMod)).Result as AcceptedResult;
Assert.NotNull(actionResult);
Assert.Equal(202, actionResult.StatusCode);
}
private void btnTask_Click(object sender, RoutedEventArgs e)
{
DataContext = new TaskMod();
}
