public void CreateToDoListItem_ReturnsOKResult()
{
//Arrange
var httpContext = new DefaultHttpContext();
CreateToDoItemCommand command = new CreateToDoItemCommand();
command.Name = "Test";
command.Completed = false;
var mediator = new Mock <IMediator>();
mediator.Setup(m => m.Send(It.IsAny <CreateToDoItemCommand>(), new System.Threading.CancellationToken()));
var controller = new ToDoListController(mediator.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = httpContext,
}
};
//ACT
var result = controller.CreateToDoListItem(command);
//ASSERT
Assert.IsType <ActionResult <ToDoItemListDto> >(result.Result);
Assert.Null(result.Result.Value);
}
public ToDoListTest()
{
this.mockRepository = new MockRepository(MockBehavior.Strict);
this.mappingServiceMock = this.mockRepository.Create <IMappingService <EntityDbContext> >();
this.toDoListServiceMock = this.mockRepository.Create <IToDoListService>();
this.controller = new ToDoListController(this.mappingServiceMock.Object, this.toDoListServiceMock.Object);
}
public async void GetToDoListItems_NoResults_ReturnsOK()
{
//Arrange
var httpContext = new DefaultHttpContext();
GetAllItemsQuery query = new GetAllItemsQuery();
var mediator = new Mock <IMediator>();
mediator.Setup(m => m.Send(It.IsAny <GetAllItemsQuery>(), new System.Threading.CancellationToken()));
var controller = new ToDoListController(mediator.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = httpContext,
}
};
//ACT
var result = await controller.GetToDoListItems();
//ASSERT
Assert.IsType <OkObjectResult>(result.Result);
}
public void CallToDoListModelServiceMethodCreateToDoList_IsCalledOnce()
{
//Arrange
var mokcedToDoListModelService = new Mock <IToDoListModelService>();
var mokcedUserService = new Mock <IUserService>();
var mockedToDoListViewModel = new Mock <ToDoListViewModel>();
mockedToDoListViewModel.Object.Category = CategoryTypes.Entertainment;
mockedToDoListViewModel.Object.IsPublic = true;
mockedToDoListViewModel.Object.Name = "Name";
var controller = new ToDoListController(mokcedToDoListModelService.Object, mokcedUserService.Object);
var controllerContext = new Mock <ControllerContext>();
var principal = new Mock <IPrincipal>();
principal.SetupGet(x => x.Identity.Name).Returns("Username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(principal.Object);
controller.ControllerContext = controllerContext.Object;
//Act
controller.Create(mockedToDoListViewModel.Object);
//Assert
mokcedToDoListModelService.Verify(u => u.CreateToDoList(It.IsAny <ApplicationUser>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <CategoryTypes>()), Times.Once);
}
public async void DeleteToDoListItem_ReturnsNoContentResult()
{
//Arrange
var httpContext = new DefaultHttpContext();
DeleteToDoItemCommand command = new DeleteToDoItemCommand();
var mediator = new Mock <IMediator>();
mediator.Setup(m => m.Send(It.IsAny <DeleteToDoItemCommand>(), new System.Threading.CancellationToken()));
var controller = new ToDoListController(mediator.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = httpContext,
}
};
//ACT
var result = await controller.DeleteToDoItem(command);
//ASSERT
Assert.IsType <NoContentResult>(result);
}
public async void CanReadAToDoList()
{
DbContextOptions <ToDoDbContext> options =
new DbContextOptionsBuilder <ToDoDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (ToDoDbContext context = new ToDoDbContext(options))
{
ToDoList list = new ToDoList
{
ID = 1,
Name = "test list",
IsDone = true
};
ToDoListController tdlc = new ToDoListController(context);
await tdlc.Create(list);
var findList = await tdlc.GetById(list.ID);
var result = (ObjectResult)findList.Result;
var readList = (ToDoList)result.Value;
Assert.Equal(list.Name, readList.Name);
}
}
public async void CreateToDoListItem_ReturnsValidDto_ReturnsOKResult()
{
//Arrange
var httpContext = new DefaultHttpContext();
var items = await GetToDoListItemsFromFileAsync();
CreateToDoItemCommand command = new CreateToDoItemCommand();
command.Name = "Test";
command.Completed = false;
var mediator = new Mock <IMediator>();
mediator.Setup(m => m.Send(It.IsAny <CreateToDoItemCommand>(), new System.Threading.CancellationToken()))
.Returns(Task.FromResult(items.First()));
var controller = new ToDoListController(mediator.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = httpContext,
}
};
//ACT
var result = await controller.CreateToDoListItem(command);
//ASSERT
Assert.IsType <OkObjectResult>(result.Result);
Assert.NotNull(result.Result);
}
public async void CanPutList()
{
DbContextOptions <ToDoNgDbContext> options = new DbContextOptionsBuilder <ToDoNgDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (ToDoNgDbContext context = new ToDoNgDbContext(options))
{
// Arrange
ToDoListController controller = new ToDoListController(context);
CreatedAtActionResult result = await controller.Post(new ToDoList
{
Name = "Hello, world!"
}) as CreatedAtActionResult;
ToDoList newList = result.Value as ToDoList;
int newListId = newList.Id;
string newListOriginalName = string.Copy(newList.Name);
// Act
await controller.Put(newListId, new ToDoList()
{
Id = newListId,
Name = "Goodbye!"
});
// Assert
Assert.NotEqual(newListOriginalName,
(await context.ToDoList.FirstOrDefaultAsync(l => l.Id == newListId)).Name);
}
}
public async void CanGetLists()
{
DbContextOptions <ToDoNgDbContext> options = new DbContextOptionsBuilder <ToDoNgDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (ToDoNgDbContext context = new ToDoNgDbContext(options))
{
// Arrange
await context.ToDoList.AddRangeAsync(
new ToDoList()
{
Name = "Hello",
},
new ToDoList()
{
Name = "Goodbye",
}
);
await context.SaveChangesAsync();
ToDoListController controller = new ToDoListController(context);
// Act
OkObjectResult result = controller.GetAll() as OkObjectResult;
DbSet <ToDoList> lists = result.Value as DbSet <ToDoList>;
// Assert
Assert.Equal(2, await lists.CountAsync());
}
}
public async void CanDeleteList()
{
DbContextOptions <ToDoNgDbContext> options = new DbContextOptionsBuilder <ToDoNgDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (ToDoNgDbContext context = new ToDoNgDbContext(options))
{
// Arrange
ToDoListController controller = new ToDoListController(context);
CreatedAtActionResult postResult = await controller.Post(new ToDoList()
{
Name = "Hello, world!"
}) as CreatedAtActionResult;
int afterPostCount = await context.ToDoList.CountAsync();
// Act
await controller.Delete((postResult.Value as ToDoList).Id);
// Assert
Assert.True(afterPostCount > (await context.ToDoList.CountAsync()));
}
}
public Menu(IWriter writer, IReader reader, UserController userController, ToDoListController toDoListController)
{
_userController = userController;
_toDoListController = toDoListController;
_reader = reader;
_writer = writer;
}
public void AddToDoListTest()
{
var mediator = new Mock <IMediator>();
var patchToDo = new Mock <IPatchToDo>();
var todoItem = new Domain.Models.BaseToDoItem()
{
IsComplete = true,
LabelId = 1,
Name = "Item 1",
UserId = 1
};
AddToDoListCommand command = new AddToDoListCommand
{
ToDoList = new Domain.Models.BaseToDoList()
{
LabelId = 1,
Name = "List 1",
TodoItems = new List <Domain.Models.BaseToDoItem>()
{
todoItem
},
UserId = 1
}
};
mediator.Setup(e => e.Send(command, new System.Threading.CancellationToken())).Returns(Task.FromResult(1));
ToDoListController controller = new ToDoListController(patchToDo.Object, mediator.Object);
var result = controller.AddToDoList(command);
var response = result.Result as OkObjectResult;
Assert.AreEqual(1, (int)response.Value);
}
public void CanDeleteAToDoList()
{
DbContextOptions <ToDoDbContext> options =
new DbContextOptionsBuilder <ToDoDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (ToDoDbContext context = new ToDoDbContext(options))
{
ToDoList list = new ToDoList
{
ID = 1,
Name = "test list",
IsDone = true
};
ToDoListController tdlc = new ToDoListController(context);
var result = tdlc.Create(list).Result;
var results = context.ToDoLists.Where(i => i.Name == "test list");
Assert.Equal(1, results.Count());
var remove = tdlc.Delete(list.ID);
Assert.True(remove.IsCompletedSuccessfully);
}
}
public void UserServiceMethodGetById_IsCalledOnce()
{
//Arrange
var mokcedToDoListModelService = new Mock <IToDoListModelService>();
var mokcedUserService = new Mock <IUserService>();
var controller = new ToDoListController(mokcedToDoListModelService.Object, mokcedUserService.Object);
var user = new ApplicationUser();
mokcedUserService.Setup(s => s.GetUserById(It.IsAny <string>())).Returns(user);
var controllerContext = new Mock <ControllerContext>();
var principal = new Mock <IPrincipal>();
principal.SetupGet(x => x.Identity.Name).Returns("Username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(principal.Object);
controller.ControllerContext = controllerContext.Object;
//Act
controller.ListsAndTasks(It.IsAny <string>());
//Assert
mokcedUserService.Verify(u => u.GetUserById(It.IsAny <string>()), Times.Once);
}
public void Setup()
{
controller = new ToDoListController(ToDoListService.Object, Mapper)
{
ControllerContext = Context
};
}
public void Put()
{
// 排列
ToDoListController controller = new ToDoListController();
Assert.AreEqual("update success", controller.Put("6", "buy some toys"));
}
public void Redirect_WithCorrectParameters()
{
//Arrange
var mokcedToDoListModelService = new Mock <IToDoListModelService>();
var mokcedUserService = new Mock <IUserService>();
var mockedToDoListViewModel = new Mock <ToDoListViewModel>();
mockedToDoListViewModel.Object.Category = CategoryTypes.Entertainment;
mockedToDoListViewModel.Object.IsPublic = true;
mockedToDoListViewModel.Object.Name = "Name";
var controller = new ToDoListController(mokcedToDoListModelService.Object, mokcedUserService.Object);
var controllerContext = new Mock <ControllerContext>();
var principal = new Mock <IPrincipal>();
principal.SetupGet(x => x.Identity.Name).Returns("Username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(principal.Object);
controller.ControllerContext = controllerContext.Object;
//Act&Assert
controller.WithCallTo(c => c.Create(mockedToDoListViewModel.Object))
.ShouldRedirectTo(r => r.ListsAndTasks(It.IsAny <string>()));
}
public void Get()
{
// 排列
ToDoListController controller = new ToDoListController();
Assert.AreEqual("select success", controller.Get());
}
public void Delete()
{
// 排列
ToDoListController controller = new ToDoListController();
Assert.AreEqual("delete success", controller.Delete("5"));
}
public void dbConnect()
{
// 排列
ToDoListController controller = new ToDoListController();
Assert.AreEqual("dbConnect success", controller.dbConnect());
}
public void Index_ReturnOneToDoList()
{
//Arrange
IToDoListService toDoListServiceFake = A.Fake <IToDoListService>();
List <ToDoList> toDoLists = new List <ToDoList>
{
CreateToDoListDefault()
};
A.CallTo(() => toDoListServiceFake.ToDoLists())
.Returns(toDoLists);
ToDoListController sut = CreateSut(toDoListServiceFake);
//Act
IActionResult result = sut.Index().Result;
//Assert
result
.As <ViewResult>()
.Model
.As <List <ToDoList> >()
.Should()
.HaveCount(1);
}
public void EditPost_InvalidModalState_ReturnViewWithOneModelStateError()
{
//Arrange
int toDoListId = 1;
ToDoList toDoList = new ToDoList
{
Id = 1
};
IToDoListService toDoListServiceFake = A.Fake <IToDoListService>();
ToDoListController sut = CreateSut(toDoListServiceFake);
string modelStateErrorKey = "Name";
sut.ModelState.AddModelError(modelStateErrorKey, "Name is required.");
//Act
IActionResult result = sut.Edit(toDoListId, toDoList).Result;
//Assert
result
.As <ViewResult>()
.ViewData
.ModelState[modelStateErrorKey]
.Errors
.Should()
.HaveCount(1);
}
public void EditPost_ConcurrencyInUpdateAndToDoListExists_ThrowsDbUpdateConcurrencyException()
{
//Arrange
const int toDoListId = 1;
ToDoList toDoList = CreateToDoListDefault();
IToDoListService toDoListServiceFake = A.Fake <IToDoListService>();
DbUpdateConcurrencyException dbUpdateConcurrencyException =
new DbUpdateConcurrencyException(
"Update concurrency exception",
new List <IUpdateEntry> {
A.Fake <IUpdateEntry>()
});
A.CallTo(() => toDoListServiceFake.Update(A <ToDoList> .Ignored))
.ThrowsAsync(dbUpdateConcurrencyException);
A.CallTo(() => toDoListServiceFake.Exists(A <int> .Ignored))
.Returns(true);
ToDoListController sut = CreateSut(toDoListServiceFake);
//Act
Func <Task <IActionResult> > action = () => sut.Edit(toDoListId, toDoList);
//Assert
action
.Should()
.Throw <DbUpdateConcurrencyException>();
}
public void SetUp()
{
var todoMock = new Mock <IToDoRepository>();
var metricsMock = new Mock <IMetricsTrackerRepository>();
todoMock.Setup(x => x.GetListDataStores());
sut = new ToDoListController(todoMock.Object, metricsMock.Object);
}
public void When_Trying_to_Call_An_Invalid_Task()
{
todomock = new Mock <IToDoRepository>();
metricMock = new Mock <IMetricsTrackerRepository>();
todomock.Setup(repository => repository.GetById("50"));
sut = new ToDoListController(todomock.Object, metricMock.Object);
}
public void Post()
{
// 排列
ToDoListController controller = new ToDoListController();
//Assert.AreEqual("buy some cake", controller.Post("buy some cake"));
//Assert.AreEqual("buy some book", controller.Post("buy some book"));
Assert.AreEqual("shopping", controller.Post("shopping"));
}
public void Render_DefulatView()
{
//Arrange
var mokcedToDoListModelService = new Mock <IToDoListModelService>();
var mokcedUserService = new Mock <IUserService>();
var controller = new ToDoListController(mokcedToDoListModelService.Object, mokcedUserService.Object);
//Act&Assert
controller.WithCallTo(c => c.Create()).ShouldRenderDefaultView();
}
public void Controller_Should_Add_New_Task_When_Add_Method_Called()
{
var controller = new ToDoListController(new MockedRepository());
controller.Add(new Task {
Id = 4, Name = "Play football"
});
Assert.AreEqual(4, controller.GetAll().Count());
}
public void Throw_WhenIdIsNull()
{
//Arrange
var mokcedToDoListModelService = new Mock <IToDoListModelService>();
var mokcedUserService = new Mock <IUserService>();
var controller = new ToDoListController(mokcedToDoListModelService.Object, mokcedUserService.Object);
//Act&Assert
Assert.Throws <ArgumentNullException>(() => { controller.DeleteList(null); });
}
public void Throw_WhenIdIsEmpty()
{
//Arrange
var mokcedToDoListModelService = new Mock <IToDoListModelService>();
var mokcedUserService = new Mock <IUserService>();
var controller = new ToDoListController(mokcedToDoListModelService.Object, mokcedUserService.Object);
//Act&Assert
Assert.Throws <ArgumentException>(() => { controller.Edit(string.Empty); });
}
