public async Task TestPutAsync_VerifyServiceReturnBadRequestWhenTaskDetailIsNotValidToClose()
{
var mockManageTask = new Mock <IManageTask>();
var taskRepository = new TasksController(mockManageTask.Object, fixture.Logger);
var taskDetail = new TaskDetail()
{
Id = 1001, Name = "Task 1", Priority = 10, EndTask = true
};
mockManageTask.Setup(manage => manage.IsTaskValidToClose(taskDetail)).Returns(false);
var statusResult = await taskRepository.PutAsync(1001, taskDetail);
Assert.NotNull(statusResult as BadRequestObjectResult);
Assert.Equal("You can not close this task as the task have child tasks", (statusResult as BadRequestObjectResult).Value);
}
public void SetUp()
{
ServiceLocatorInitializer.Init();
controller = new TasksController(
CreateMockTaskRepository(),
MockRepository.GenerateMock <IUserRepository>(),
TipsControllerTests.CreateMockTipRepository(),
CodesControllerTests.CreateMockCodeRepository());
testContext = new ControllerTestContext(controller);
user = new User {
Game = new Game()
};
}
public TasksControllerTests()
{
_mockTasksRepo = new Mock <ITasksRepo>();
_mockTaskListsRepo = new Mock <ITaskListsRepo>();
_mockTagsRepo = new Mock <ITagsRepo>();
_mockTaskTagsRepo = new Mock <ITaskTagsRepo>();
_mapper = Mapper.Configuration.CreateMapper();
_mockLogger = new Mock <ILogger <TasksController> >();
_controller = new TasksController(_mockTasksRepo.Object,
_mockTaskListsRepo.Object,
_mockTagsRepo.Object,
_mockTaskTagsRepo.Object,
_mapper,
_mockLogger.Object);
}
public async Task GetTest()
{
using (var context = new TaskContext(options))
{
context.Tasks.Add(new Tasks("Cim", "Done", new DateTime(), "Leiras"));
context.Tasks.Add(new Tasks("Cim2", "Pending", new DateTime(), "Leiras2"));
context.SaveChanges();
TasksController controller = new TasksController(context);
var result = await controller.GetTasks(1);
var actualResult = result.Value;
Assert.AreEqual("Cim", ((Tasks)actualResult).Title);
}
}
public void GetTaskByIDTest()
{
taskController = new TasksController(_taskBusiness);
//Number of records
var taskModels = taskController.GetById(1);
if (taskModels != null)
{
Assert.True(taskModels != null);
}
else
{
Assert.Fail();
}
}
public async void Get_Tasks_ShouldBeNoContent()
{
var mockProxy = new Mock <ITasksProxy>();
mockProxy.Setup(repo => repo.GetTasksAsync())
.ReturnsAsync(GetEmptyTestTasks());
var controller = new TasksController(mockProxy.Object);
var result = await controller.GetTasks();
Assert.NotNull(result);
Assert.IsType <ActionResult <List <TaskModel> > >(result);
Assert.IsType <NoContentResult>(result.Result);
}
private void Stop()
{
// cancel the token
_cts?.Cancel();
// stop the mail processor
TheMailProcessor.Stop();
// wait for the tasks to be done
TasksController.WaitAll();
// clean up
_cts?.Dispose();
_cts = null;
}
public void UpdateTaskReturnsBadRequestOnInvalidData()
{
var taskData = new TaskCreateUpdateRequestDto()
{
Title = "test",
Description = "test"
};
TasksController controller = this.TasksControllerInstance;
controller.ModelState.AddModelError("error", "error");
IActionResult result = controller.UpdateTask(taskData);
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task TestPutAsync_WhenManageTaskThrowsExceptionVerifyServiceReturnInternalServerErrorStatus()
{
var mockManageTask = new Mock <IManageTask>();
var taskRepository = new TasksController(mockManageTask.Object, fixture.Logger);
var taskDetail = new TaskDetail()
{
Id = 1001, Name = "Task 1", Priority = 10
};
mockManageTask.Setup(manage => manage.EditTaskAsync(1001, taskDetail)).Throws(new Exception());
var statusResult = await taskRepository.PutAsync(1001, taskDetail);
Assert.Equal((int)HttpStatusCode.InternalServerError, (statusResult as ObjectResult).StatusCode);
}
public void search_throwException()
{
int id = -21;
string description = "Test";
DateTime dueDate = DateTime.Now;
String title = "Test Task";
var Task = new List <TaskDto>()
{
new TaskDto()
{
TaskId = 1
}
};
NSI.REST.Models.TasksCreateModel task = new TasksCreateModel()
{
TaskId = id,
Description = description,
DueDate = dueDate,
Title = title
};
var task2 = new TaskDto
{
TaskId = id,
Description = description,
DueDate = dueDate,
Title = title
};
var taskSearchModel = new TasksSearchModel()
{
TaskId = id,
Description = description,
DueDate = dueDate,
Title = title
};
var taskRepo = new Mock <ITaskRepository>();
var taskManipulation = new TaskManipulation(taskRepo.Object);
var controller = new TasksController(taskManipulation);
var result = controller.Search(taskSearchModel, null, null);
Assert.IsType <BadRequestObjectResult>(result);
}
public void UpdateParentTaskTest()
{
//TasksModel proj = new TasksModel();
taskObject.Task_ID = 1;
taskObject.Task = "New todo task";
taskObject.Project_ID = 4;
taskObject.IsParentTask = true;
var result = TasksController.UpdateTask(taskObject);
result.Result.Should().BeTrue();
var project = MockContext.Object.Tasks.Where(x => x.Task_ID == 1).Select(x => x.Task).FirstOrDefault();
project.Should().NotBe("Task first testing");
}
public void InsertParentTaskTest()
{
//TasksModel proj = new TasksModel();
taskObject.Task = "New todo task";
taskObject.Project_ID = 4;
taskObject.IsParentTask = true;
var result = TasksController.InsertTaskAsync(taskObject);
result.Result.Should().BeTrue();
//Assert.AreEqual(MockContext.Object.Tasks.Count(), 3);
MockContext.Object.Tasks.Count().Equals(3);
//MockContext.Verify(m => m.SaveChangesAsync(), Times.Once);
}
public void EditTask_ShouldEditTask()
{
var demoTask = GetDemoTask();
var context = new TestKenDoContext();
context.MyTasks.Add(demoTask);
var controller = new TasksController(context);
var newTaskDto = new TaskDto {
Description = "Edit a dang task"
};
var result = controller.EditTask(demoTask.ID, newTaskDto) as OkNegotiatedContentResult <TaskDto>;
Assert.IsNotNull(result);
Assert.AreEqual(newTaskDto.Description, result.Content.Description);
}
public void GetTaskWithDueDateRange_ReturnBadRequest()
{
var logger = new Mock <Microsoft.Extensions.Logging.ILogger <TasksController> >().Object;
var taskMan = new Mock <ITaskManipulation>();
var controller = new TasksController(taskMan.Object);
controller.ModelState.AddModelError("error", "some error");
DateTime dateFrom = DateTime.Now;
DateTime dateTo = DateTime.Now.AddYears(-1);
var result = controller.GetTasksWithDueDateRange(dateFrom, dateTo, 1, 1);
Xunit.Assert.IsType <BadRequestObjectResult>(result);
}
public void DeleteTaskTestMethod()
{
var tskCtrl = new TasksController();
var tskid = TestId;
var actResult = tskCtrl.Deletetask(tskid);
var createdResult = actResult as OkNegotiatedContentResult <task>;
Debug.WriteLine(actResult);
Assert.AreEqual(tskid, createdResult.Content.task_id);
}
private static TasksController BuildController(Mock <IMediator> mediator)
{
var logger = new Mock <ILogger <TasksController> >();
var controller = new TasksController(mediator.Object,
logger.Object)
{
ControllerContext = new ControllerContext()
};
controller.ControllerContext.HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity("",
"testUserName", "testUserRole"))
};
return(controller);
}
public void POST_To_Slash_Tasks_Slash_New_Redirects_To_Slash_Tasks()
{
// Arrange
TasksController controller = new TasksController();
Task newTask = new Task()
{
Description = "Description"
};
// Act
RedirectToRouteResult result = controller.New(newTask) as RedirectToRouteResult;
// Assert
Assert.AreEqual("tasks", result.RouteValues["controller"]);
Assert.AreEqual("index", result.RouteValues["action"]);
}
public void TestsInitialize()
{
queryHandler = new Mock <IQueryHandler>();
commandHandler = new Mock <ICommandHandler>();
logger = new Mock <ILogger <TasksController> >();
var task = new VideoApi.Domain.Task(Guid.NewGuid(), Guid.NewGuid(), "Test body", VideoApi.Domain.Enums.TaskType.Hearing);
queryHandler
.Setup(x => x.Handle <GetTasksForConferenceQuery, List <VideoApi.Domain.Task> >(It.IsAny <GetTasksForConferenceQuery>()))
.ReturnsAsync(new List <VideoApi.Domain.Task> {
task
});
tasksController = new TasksController(queryHandler.Object, commandHandler.Object, logger.Object);
}
public void GetTasks_ShouldReturnAllTasks()
{
var context = new TestKenDoContext();
var sampleTasks = MyTask.GenerateSampleData();
foreach (var t in sampleTasks)
{
context.MyTasks.Add(t);
}
var controller = new TasksController(context);
var result = controller.GetTasks() as OkNegotiatedContentResult <TaskDto[]>;
Assert.IsNotNull(result);
Assert.AreEqual(sampleTasks.Count, result.Content.Length);
}
public void Test_For_PostNewTask()
{
var testCxt = new TestTaskManDb();
ctrler = new TasksController(testCxt);
var newTestTask = new Models.Task()
{
TaskName = "Testing for posting a new task", Priority = 5, StartDate = DateTime.Today
};
var result = ctrler.PostTask(newTestTask) as CreatedAtRouteNegotiatedContentResult <Models.Task>;
Assert.IsNotNull(result);
Assert.IsNotNull(result.Content);
Assert.AreEqual(newTestTask.TaskName, result.Content.TaskName);
}
public async void Get_Tasks_ShouldBeOk()
{
var mockProxy = new Mock <ITasksProxy>();
mockProxy.Setup(repo => repo.GetTasksAsync())
.ReturnsAsync(GetTwoTestTasks());
var controller = new TasksController(mockProxy.Object);
var result = await controller.GetTasks();
Assert.NotNull(result);
var actionResult = Assert.IsType <ActionResult <List <TaskModel> > > (result);
var returnValue = Assert.IsType <List <TaskModel> >(actionResult.Value);
Assert.Equal(2, returnValue.Count);
}
public void AddParentTaskTest_Error()
{
// Arrange
var taskController = new TasksController(null);
ProjectMangerModel.ParentTasks model = new ProjectMangerModel.ParentTasks
{
ParentTaskID = 3,
ParentTask = "Parent Task 3"
};
// Act
var response = taskController.AddParentTask(model);
// Assert
Assert.IsTrue(response is InternalServerErrorResult);
}
public void PutShouldUpdateTask()
{
var controller = new TasksController();
DateTime datetime = new DateTime();
var task = new Models.Task {
Task_Name = "Test task", Start_Date = DateTime.Now, End_Date = datetime.AddDays(2), Project_ID = 1, Parent_ID = 1, ISTaskEnded = "N", Task_Priority = 0, Status = 1
};
var actionResult = controller.PutTask(task.Task_ID, task);
var response = actionResult as OkNegotiatedContentResult <Task>;
var actionResult1 = controller.GetTask(1);
var response1 = actionResult1 as OkNegotiatedContentResult <Models.Task>;
var newtask = response1.Content;
Assert.AreEqual(3, newtask.User_ID);
Assert.AreEqual("Test", newtask.Task_Name);
Assert.AreEqual(10, newtask.Task_Priority);
}
public async void Get_Second_Task_ShouldBeNotFound()
{
var mockProxy = new Mock <ITasksProxy>();
mockProxy.Setup(repo => repo.GetTasksAsync())
.ReturnsAsync(GetTwoTestTasks());
var controller = new TasksController(mockProxy.Object);
var result = await controller.GetTask(SecondTaskId);
Assert.NotNull(result);
var actionResult = Assert.IsType <ActionResult <TaskModel> >(result);
var notFoundResult = Assert.IsType <NotFoundObjectResult>(actionResult.Result);
Assert.Equal(SecondTaskId, notFoundResult.Value);
}
public async Task ChangeTaskWithWrongId()
{
var controller = new TasksController(unit.Context);
int id = 140;//Try to change the task with id (doesn't exist)
JobDetail task = new JobDetail
{
Id = id,
Day = unit.Calendar.Get(1),
Project = unit.Projects.Get(1),
Hours = 7
};
var response = await controller.Put(id, task) as ObjectResult;
Assert.AreEqual(404, response.StatusCode);
}
public async Task InsertTask()
{
var controller = new TasksController(unit.Context);
JobDetail task = new JobDetail
{
Day = unit.Calendar.Get(1),
Project = unit.Projects.Get(1)
};
var response = await controller.Post(task) as ObjectResult;
var value = response.Value as JobDetailModel;
Assert.AreEqual(200, response.StatusCode);
Assert.AreEqual(98, value.Id);//Id of the new task will be 98
}
public void PostTask_ShouldReturnSameProduct()
{
var context = new TestProjectMangerContext();
var controller = new TasksController(context);
context.Users.Add(GetDemoUser());
var item = GetDemoTask();
var result =
controller.PostTask(item) as CreatedAtRouteNegotiatedContentResult <Task>;
Assert.IsNotNull(result);
Assert.AreEqual(result.RouteName, "DefaultApi");
Assert.AreEqual(result.RouteValues["id"], result.Content.Task_ID);
Assert.AreEqual(result.Content.Task_Name, item.Task_Name);
}
public void TasksController_Update_CompleteTask_RetunsBadRequest_WhenTaskIsAlreadyCompleted()
{
//Arrange
int taskId = 1;
controller = createContext(controller, "Employer");
var retrieveTask = controller.Get(taskId) as ObjectResult;
var task = retrieveTask.Value as Task;
task.Completed = true;
//Act
var result = controller.CompleteTask(taskId);
//Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public void Task_Cannot_Edit_Nonexistent()
{
// Arrange
Mock <ILogger <TasksController> > mockLogger = new Mock <ILogger <TasksController> >();
Mock <ITaskListRepository> mockTaskListRepository = new Mock <ITaskListRepository>();
Mock <IStatusRepository> mockStatusRepository = new Mock <IStatusRepository>();
Mock <ILocationRepository> mockLocationRepository = new Mock <ILocationRepository>();
Mock <IIdentityRepository> mockIdentityRepository = new Mock <IIdentityRepository>();
TasksController controller = new TasksController(mockLogger.Object, mockTaskListRepository.Object, mockStatusRepository.Object, mockLocationRepository.Object, mockIdentityRepository.Object);
// Act
Task result = GetViewModel <Task>(controller.Edit(4));
// Assert
Assert.IsNull(result);
}
public void GetTaskWithDueDateRange_ReturnOK() //dateFrom, dateTo, page,pageSize
{
int id = 21;
string description = "Test";
DateTime dueDateFrom = DateTime.Now;
DateTime dueDateTo = DateTime.Now;
dueDateTo.AddYears(1);
String title = "Test Task";
var Task = new List <TaskDto>()
{
new TaskDto()
{
TaskId = 1
}
};
NSI.REST.Models.TasksCreateModel task = new TasksCreateModel()
{
TaskId = id,
Description = description,
DueDate = dueDateFrom,
Title = title
};
var task2 = new TaskDto
{
TaskId = id,
Description = description,
DueDate = dueDateFrom,
Title = title
};
var taskRepo = new Mock <ITaskRepository>();
taskRepo.Setup(x => x.CreateTask(task2));
var taskManipulation = new TaskManipulation(taskRepo.Object);
var controller = new TasksController(taskManipulation);
var result = controller.GetTasksWithDueDateRange(dueDateFrom, dueDateTo, 1, 1);
Assert.IsType <OkObjectResult>(result);
}
