public void CreateTest()
{
// Arrange
var mockDbSet = new Mock <DbSet <TaskItem> >();
var mockContext = new Mock <ApplicationDbContext>();
mockContext.Setup(item => item.Tasks).Returns(mockDbSet.Object);
var repository = new Mock <TaskRepository>(mockContext.Object);
// Act
var expTaskDTO = new TaskItemDTO {
Id = "4", Description = "ssss"
};
var userRep = new Mock <UserRepository>(mockContext.Object);
var mapper = new Mock <IMapper>();
var userService = new Mock <UserService>(userRep.Object);
var catRep = new Mock <CategoryRepository>(mockContext.Object);
var taskRep = new Mock <TaskCategoryRepository>(mockContext.Object);
var service = new Mock <TaskService>(repository.Object, userRep.Object, catRep.Object, taskRep.Object, mapper.Object);
var principal = new Mock <ClaimsPrincipal>();
principal.Setup(b => b.Identity.IsAuthenticated).Returns(true);
principal.Setup(b => b.FindFirst(It.IsAny <string>())).Returns(new Claim(ClaimTypes.NameIdentifier, "1"));
service.Setup(x => x.Create(principal.Object, expTaskDTO));
service.Object.Create(principal.Object, expTaskDTO);
service.Verify(i => i.Create(principal.Object, expTaskDTO));
}
public IActionResult Edit(string id, [Bind("Id,Title,Description,EstimatedTime,Progress,StartDate,EndDate,CategoriesStr,Priority,Status,UserId")] TaskItemDTO taskItemDTO)
{
if (id != taskItemDTO.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_taskService.Update(taskItemDTO);
}
catch (DbUpdateConcurrencyException)
{
if (!_taskService.Any(taskItemDTO.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Active)));
}
ViewBag.Categories = GetUserCategories();
return(View(taskItemDTO));
}
public void DeleteTest()
{
// Arrange
var mockDbSet = new Mock <DbSet <TaskItem> >();
var mockContext = new Mock <ApplicationDbContext>();
mockContext.Setup(item => item.Tasks).Returns(mockDbSet.Object);
var repository = new Mock <TaskRepository>(mockContext.Object);
var userRep = new Mock <UserRepository>(mockContext.Object);
var mapper = new Mock <IMapper>();
var task = new TaskItemDTO {
Id = "1", Description = "Description", UserId = "1"
};
var taskItem = new TaskItem {
Id = "1", Description = "Description", UserId = "1"
};
mapper.Setup(x => x.Map <TaskItem>(task)).Returns(taskItem);
mapper.Setup(x => x.Map <TaskItemDTO>(taskItem)).Returns(task);
var userService = new Mock <UserService>(userRep.Object);
var catRep = new Mock <CategoryRepository>(mockContext.Object);
var taskRep = new Mock <TaskCategoryRepository>(mockContext.Object);
var service = new Mock <TaskService>(repository.Object, userRep.Object, catRep.Object, taskRep.Object, mapper.Object);
service.Setup(x => x.Delete(task.Id));
service.Object.Delete(task.Id);
service.Verify(i => i.Delete(task.Id));
}
private void UpdateTaskCategories(string userId, TaskItemDTO taskItemDTO)
{
DeleteTaskCategoreis(taskItemDTO.Id);
var categoriesList = taskItemDTO.CategoriesStr.Split(',').ToList();
var categories = SyncCategories(categoriesList, userId);
CreateTaskCategories(categories, taskItemDTO.Id);
}
public void UpdateTest()
{
// Arrange
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "update")
.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)
.Options;
var context = new ApplicationDbContext(options);
var repository = new TaskRepository(context);
var userRep = new Mock <UserRepository>(context);
var mapper = new Mock <IMapper>();
var task = new TaskItemDTO {
Id = "1", Description = "Description", UserId = "1"
};
var taskItem = new TaskItem {
Id = "1", Description = "Description", UserId = "1"
};
mapper.Setup(x => x.Map <TaskItem>(task)).Returns(taskItem);
mapper.Setup(x => x.Map <TaskItemDTO>(taskItem)).Returns(task);
var task1 = new TaskItemDTO {
Id = "1", Description = "new", UserId = "1"
};
var taskItem1 = new TaskItem {
Id = "1", Description = "new", UserId = "1"
};
mapper.Setup(x => x.Map <TaskItem>(task1)).Returns(taskItem1);
mapper.Setup(x => x.Map <TaskItemDTO>(taskItem1)).Returns(task1);
var principal = new Mock <ClaimsPrincipal>();
principal.Setup(b => b.Identity.IsAuthenticated).Returns(true);
principal.Setup(b => b.FindFirst(It.IsAny <string>())).Returns(new Claim(ClaimTypes.NameIdentifier, "1"));
var userService = new Mock <UserService>(userRep.Object);
//repository.Setup(i => i.FindAsNoTracking(It.IsAny<string>())).Returns(taskItem1);
var catRep = new Mock <CategoryRepository>(context);
var taskRep = new Mock <TaskCategoryRepository>(context);
var service = new Mock <TaskService>(repository, userRep.Object, catRep.Object, taskRep.Object, mapper.Object);
var categoryService = new Mock <ICategoryService>();
var controller = new TaskController(service.Object, categoryService.Object);
// Act
controller.Create(task);
task.Description = "new";
var view = controller.Edit(task.Id, task);
var str = view.ToString();
// Assert
Assert.NotNull(view);
}
public virtual void Create(ClaimsPrincipal user, TaskItemDTO taskItemDTO)
{
var categoriesList = taskItemDTO.CategoriesStr.Split(',').ToList();
var categories = SyncCategories(categoriesList, user.GetUserId());
var taskItem = _mapper.Map <TaskItem>(taskItemDTO);
taskItem.User = _userRepository.Find(user.GetUserId());
_taskRepository.Create(taskItem);
CreateTaskCategories(categories, taskItem.Id);
}
public IActionResult Create([Bind("Id,Title,Description,EstimatedTime,Progress,StartDate,EndDate,CategoriesStr,Priority,Status")] TaskItemDTO taskItemDTO)
{
if (ModelState.IsValid)
{
_taskService.Create(User, taskItemDTO);
return(RedirectToAction(nameof(Active)));
}
ViewBag.Categories = GetUserCategories();
return(View(taskItemDTO));
}
public void CreateTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "update")
.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)
.Options;
var context = new ApplicationDbContext(options);
var repository = new TaskRepository(context);
var userRep = new Mock <UserRepository>(context);
var mapper = new Mock <IMapper>();
var principal = new Mock <ClaimsPrincipal>();
principal.Setup(b => b.Identity.IsAuthenticated).Returns(true);
principal.Setup(b => b.FindFirst(It.IsAny <string>())).Returns(new Claim(ClaimTypes.NameIdentifier, "1"));
var iden = new Mock <ClaimsIdentity>();
iden.Setup(i => i.IsAuthenticated).Returns(true);
iden.Setup(b => b.FindFirst(It.IsAny <string>())).Returns(new Claim(ClaimTypes.NameIdentifier, "1"));
var task = new TaskItemDTO {
Id = "1", Description = "Description", UserId = "1"
};
var taskItem = new TaskItem {
Id = "1", Description = "Description", UserId = "1"
};
mapper.Setup(x => x.Map <TaskItem>(task)).Returns(taskItem);
var userService = new Mock <UserService>(userRep.Object);
var catRep = new Mock <CategoryRepository>(context);
var taskRep = new Mock <TaskCategoryRepository>(context);
var service = new Mock <TaskService>(repository, userRep.Object, catRep.Object, taskRep.Object, mapper.Object);
service.Setup(i => i.Create(principal.Object, task));
var categoryService = new Mock <ICategoryService>();
var controller = new TaskController(service.Object, categoryService.Object);
// Act
var view = controller.Create(task);
// Assert
Assert.Equal("Microsoft.AspNetCore.Mvc.RedirectToActionResult", view.ToString());
}
public virtual void Update(TaskItemDTO taskItemDTO)
{
var prevTaskItem = _taskRepository.FindAsNoTracking(taskItemDTO.Id);
UpdateTaskCategories(taskItemDTO.UserId, taskItemDTO);
var taskItem = _mapper.Map <TaskItem>(taskItemDTO);
var diff = GetDiff(prevTaskItem, taskItem, taskItemDTO.CategoriesStr);
foreach (var item in diff)
{
taskItem.Changes.Add(item);
}
_taskRepository.Update(taskItem);
}
public void DeleteTest()
{
// Arrange
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "delete2")
.Options;
var context = new ApplicationDbContext(options);
var repository = new TaskRepository(context);
var principal = new Mock <ClaimsPrincipal>();
principal.Setup(b => b.Identity.IsAuthenticated).Returns(true);
principal.Setup(b => b.FindFirst(It.IsAny <string>())).Returns(new Claim(ClaimTypes.NameIdentifier, "1"));
var userRep = new Mock <UserRepository>(context);
var categoryRep = new Mock <CategoryRepository>(context);
var taskCategoriesRep = new Mock <TaskCategoryRepository>(context);
var mapper = new Mock <IMapper>();
var task = new TaskItemDTO {
Id = "1", Description = "Description", UserId = "1"
};
var taskItem = new TaskItem {
Id = "1", Description = "Description", UserId = "1"
};
mapper.Setup(x => x.Map <TaskItem>(task)).Returns(taskItem);
mapper.Setup(x => x.Map <TaskItemDTO>(taskItem)).Returns(task);
var userService = new Mock <UserService>(userRep.Object);
var categoryService = new Mock <ICategoryService>();
var catRep = new Mock <CategoryRepository>(context);
var taskRep = new Mock <TaskCategoryRepository>(context);
var service = new Mock <TaskService>(repository, userRep.Object, catRep.Object, taskRep.Object, mapper.Object);
var controller = new TaskController(service.Object, categoryService.Object);
// Act
controller.Create(task);
controller.DeleteConfirmed("1");
// Assert
Assert.Equal(0, context.Tasks.Count());
}
public static TaskItem ToTask(this TaskItemDTO taskDto)
{
return(new TaskItem
{
Id = taskDto.Id,
Title = taskDto.Title,
Description = taskDto.Description,
EstimatedTime = taskDto.EstimatedTime,
Progress = taskDto.Progress,
StartDate = taskDto.StartDate,
EndDate = taskDto.EndDate,
Priority = taskDto.Priority,
Status = taskDto.Status,
Changes = taskDto.Changes,
UserId = taskDto.UserId,
});
}
public void UpdateTest()
{
// Arrange
var mockDbSet = new Mock <DbSet <TaskItem> >();
var mockContext = new Mock <ApplicationDbContext>();
mockContext.Setup(item => item.Tasks).Returns(mockDbSet.Object);
var repository = new Mock <TaskRepository>(mockContext.Object);
var userRep = new Mock <UserRepository>(mockContext.Object);
var mapper = new Mock <IMapper>();
var task = new TaskItemDTO {
Id = "1", Description = "Description", UserId = "1"
};
var taskItem = new TaskItem {
Id = "1", Description = "Description", UserId = "1"
};
mapper.Setup(x => x.Map <TaskItem>(task)).Returns(taskItem);
mapper.Setup(x => x.Map <TaskItemDTO>(taskItem)).Returns(task);
repository.Setup(i => i.FindAsNoTracking(It.IsAny <string>())).Returns(taskItem);
var userService = new Mock <UserService>(userRep.Object);
var catRep = new Mock <CategoryRepository>(mockContext.Object);
var taskRep = new Mock <TaskCategoryRepository>(mockContext.Object);
var service = new Mock <TaskService>(repository.Object, userRep.Object, catRep.Object, taskRep.Object, mapper.Object);
var cp = new Mock <ClaimsPrincipal>();
cp.Setup(m => m.HasClaim(It.IsAny <string>(), It.IsAny <string>())).Returns(true);
var mockMyImplementation = new Mock <IdentityExtension>();
IdentityExtensions.Implementation = mockMyImplementation.Object;
mockMyImplementation.Setup(m => m.GetUserId(cp.Object)).Returns("1");
// Act
service.Setup(i => i.Create(cp.Object, task));
service.Object.Create(cp.Object, task);
service.Setup(i => i.Update(task));
service.Object.Update(task);
// Assert
service.Verify(i => i.Update(task));
}
public CreateTaskOutput Execute(CreateTaskInput input)
{
if (input is null)
{
throw new ArgumentNullException(nameof(input));
}
if (input.IsValid())
{
//create new Domain TaskItem from the supplied input data
TaskItem newTask = InputToTaskItem(input);
if (taskManager.Add(newTask))
{
ITaskItemRepository taskItemRepo = taskItemRepositoryFactory.New();
//Create a TaskItemDAL to save to the database
TaskItemDAL taskItemDAL = TaskItemAndInputToDAL(newTask, input);
//add the new TaskItemDAL to the database
if (taskItemRepo.Add(taskItemDAL))
{
//save the changed make to the TaskItemRepository
if (taskItemRepo.Save())
{
//create DTO to return as Output data
TaskItemDTO taskItemDTO = InputToTaskItemDTO(input);
//fill output data and return
return(new CreateTaskOutput {
Success = true, TaskItemDTO = taskItemDTO
});
}
else
{
//failed to save state of repository
//remove taskItem from domain TaskManager
if (!taskManager.Remove(newTask))
{
//TaskItem could not be removed. we're now screwed . . .
//TODO: decide what to do here
}
return(new CreateTaskOutput {
Success = false, Error = "Unable to save the new Task."
});
}
}
else
{
//failed to save task to repository
//remove taskItem from domain TaskManager
if (!taskManager.Remove(newTask))
{
//TaskItem could not be removed. we're now screwed . . .
//TODO: decide what to do here
}
return(new CreateTaskOutput {
Success = false, Error = "Unable to save the new Task."
});
}
}
else
{
//unable to add new TaskItem to domain TaskManager
return(new CreateTaskOutput {
Success = false, Error = "Unable to process the new Task."
});
}
}
else
{
//Input is not valid
return(new CreateTaskOutput {
Success = false, Error = input.GetErrorMessage()
});
}
}
private TaskService SetUpService()
{
var list = GetTestList().AsQueryable();
var mockSet = new Mock <DbSet <TaskItem> >();
mockSet.As <IQueryable <TaskItem> >().Setup(m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <TaskItem> >().Setup(m => m.Expression).Returns(list.Expression);
mockSet.As <IQueryable <TaskItem> >().Setup(m => m.ElementType).Returns(list.ElementType);
mockSet.As <IQueryable <TaskItem> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
var mockContext = new Mock <ApplicationDbContext>();
mockContext.Setup(item => item.Tasks).Returns(mockSet.Object);
var repository = new TaskRepository(mockContext.Object);
var userRep = new Mock <UserRepository>(mockContext.Object);
var mapper = new Mock <IMapper>();
var task = new TaskItemDTO {
Id = "1", Description = "aaaa", Status = Status.Active, Priority = Priority.Critical, Categories = new List <TaskCategories>()
{
new TaskCategories {
Category = new CategoryItem {
Name = "Work", Id = "1"
}
}
}, UserId = "1"
};
var taskItem = new TaskItem {
Id = "1", Description = "aaaa", Status = Status.Active, Priority = Priority.Critical, Categories = new List <TaskCategories>()
{
new TaskCategories {
Category = new CategoryItem {
Name = "Work", Id = "1"
}
}
}, UserId = "1"
};
mapper.Setup(x => x.Map <TaskItemDTO>(taskItem)).Returns(task);
var task1 = new TaskItemDTO {
Id = "1", Description = "bbbb", Status = Status.Active, Priority = Priority.Critical, Categories = new List <TaskCategories>()
{
new TaskCategories {
Category = new CategoryItem {
Name = "Work", Id = "1"
}
}
}, UserId = "1"
};
var taskItem1 = new TaskItem {
Id = "1", Description = "bbbb", Status = Status.Active, Priority = Priority.Critical, Categories = new List <TaskCategories>()
{
new TaskCategories {
Category = new CategoryItem {
Name = "Work", Id = "1"
}
}
}, UserId = "1"
};
mapper.Setup(x => x.Map <TaskItemDTO>(taskItem1)).Returns(task1);
var task2 = new TaskItemDTO {
Id = "1", Description = "cccc", Status = Status.Closed, Priority = Priority.Critical, Categories = new List <TaskCategories>()
{
new TaskCategories {
Category = new CategoryItem {
Name = "Work", Id = "1"
}
}
}, UserId = "1"
};
var taskItem2 = new TaskItem {
Id = "1", Description = "cccc", Status = Status.Closed, Priority = Priority.Critical, Categories = new List <TaskCategories>()
{
new TaskCategories {
Category = new CategoryItem {
Name = "Work", Id = "1"
}
}
}, UserId = "1"
};
mapper.Setup(x => x.Map <TaskItemDTO>(taskItem2)).Returns(task2);
var userService = new Mock <UserService>(userRep.Object);
var catRep = new Mock <CategoryRepository>(mockContext.Object);
var taskRep = new Mock <TaskCategoryRepository>(mockContext.Object);
var service = new TaskService(repository, userRep.Object, catRep.Object, taskRep.Object, mapper.Object);
return(service);
}
/// <summary>
/// Extracts TaskItem input data from a IAddTaskView and creates a new TaskItem for the
/// application.
/// </summary>
/// <param name="view">
/// Where new TaskItem info was inputted
/// </param>
public void CreateTask(IAddTaskView view)
{
//map the view's notification frequency type string to an enum value
NotificationFrequencyType notificationFrequencyType =
frequenctTypeStrMap.Where(x => x.Value == view.FrequencyType).First().Key;
//create input for use-case from data of the view
CreateTaskInput input = new CreateTaskInput {
Title = view.Title,
Description = view.Description,
StartTime = view.StartTime,
R = view.Color.R,
G = view.Color.G,
B = view.Color.B,
NotificationFrequencyType = notificationFrequencyType,
CustomNotificationFrequency = view.CustomFrequency
};
//create UseCase instance and assign input structure to its input port
var uc = taskSchedulerApplication.NewCreateTaskUseCase();
//run the use case
CreateTaskOutput output = uc.Execute(input);
if (output.Success)
{
//get the taskItemDTO returned creatd by the executed usecase
TaskItemDTO taskDTO = output.TaskItemDTO;
//get a string representation of the taskDTO's notification frequency type
string frequencyTypeStr = frequenctTypeStrMap[taskDTO.NotificationFrequencyType];
//convert the taskDTO's rgb color to a Windows brush
SolidColorBrush colorBrush = new SolidColorBrush(Windows.UI.Color.FromArgb(255, taskDTO.R, taskDTO.G, taskDTO.B));
//create task item model from taskDTO
TaskItemModel newTaskItemModel = new TaskItemModel()
{
Id = taskDTO.Id,
Title = taskDTO.Title,
Description = taskDTO.Description,
StartTime = taskDTO.StartTime,
FrequencyType = frequencyTypeStr,
NotificationFrequency = taskDTO.CustomNotificationFrequency,
Color = colorBrush
};
//fire the TaskCreated event
OnTaskCreated(newTaskItemModel);
//clear the views input fields and close it
view.ClearFields();
view.CloseSelf();
}
else
{
//transfer the use-cases error to the view
view.ApplicationErrorMessage = output.Error;
view.ApplicationError = true;
}
}
