public async Task Get_by_id_should_return_a_valid_todo()
{
var expectedTodo = DataFactories.TodosFactory.CreateTodo(
DataFactories.TodosFactory.CreateId(),
DataFactories.TodosFactory.CreateId(),
DataFactories.TodosFactory.CreateRandomLorem(20),
true
);
var todoClientMock = new Mock <ITypecodeTodoClient>();
todoClientMock
.Setup(client => client.Get(It.IsAny <int>()))
.ReturnsAsync(expectedTodo);
var controller = new TodosController(todoClientMock.Object);
var result = await controller.Get(1) as ObjectResult;
Assert.IsNotNull(result.Value);
var actualTodo = result.Value as Todo;
Assert.AreEqual(expectedTodo.Id, actualTodo.Id);
Assert.AreEqual(expectedTodo.UserId, actualTodo.UserId);
Assert.AreEqual(expectedTodo.Title, actualTodo.Title);
Assert.AreEqual(expectedTodo.Completed, actualTodo.Completed);
}
public async Task Get_All_Is_Ok()
{
// Arrange
var mockTodoService = new Mock <ITodoService>();
var mockTodoMapper = new Mock <ITodoModelDtoMapper>();
_ = mockTodoService.Setup(s => s.GetTodos())
.ReturnsAsync(new List <TodoDto> {
new TodoDto()
}.AsEnumerable());
_ = mockTodoMapper.Setup(s => s.Map(It.IsAny <List <TodoDto> >()))
.Returns(new List <TodoResponseModel> {
new TodoResponseModel()
}.AsEnumerable());
var controller = new TodosController(mockTodoService.Object, mockTodoMapper.Object);
// Act
var result = await controller.Get();
// Assert
_ = result.Result.Should().BeOfType <OkObjectResult>();
var resultObject = result.GetObjectResult();
_ = resultObject.Should().BeOfType <List <TodoResponseModel> >();
_ = resultObject.Should().HaveCount(1);
mockTodoService.Verify(c => c.GetTodos(), Times.Once);
mockTodoMapper.Verify(c => c.Map(It.IsAny <List <TodoDto> >()), Times.Once);
}
public void Get_Todos()
{
var mockMediator = new Mock <IMediator>();
mockMediator
.Setup(t => t.Send(It.IsAny <GetTodosQuery>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new List <Todo> {
new Todo
{
Id = 1000,
Task = "Write unit test",
Done = true
}
}));
var controller = new TodosController(mockMediator.Object);
var result = controller.GetTodos();
var okResult = Assert.IsType <OkObjectResult>(result);
var todos = Assert.IsType <List <Todo> >(okResult.Value);
Assert.Single(todos);
}
public async Task GetTodos_ReturnsAnOkResultWithTodosArray()
{
// Arrange
var expectedTodos = new List <TodoDTO>()
{
new TodoDTO()
{
Id = 1, Name = "Todo 1", IsComplete = true
}
};
var mockService = new Mock <ITodosService>();
mockService.Setup(ts => ts.GetAllTodosAsync()).ReturnsAsync(expectedTodos);
var controller = new TodosController(mockService.Object);
// Action
var actualTodos = await controller.GetTodos();
// Assert
Assert.NotNull(actualTodos);
Assert.Single(actualTodos);
Assert.Equal(expectedTodos[0].Id, actualTodos.ToList()[0].Id);
Assert.Equal(expectedTodos[0].Name, actualTodos.ToList()[0].Name);
Assert.Equal(expectedTodos[0].IsComplete, actualTodos.ToList()[0].IsComplete);
}
public async Task Get_Is_Ok()
{
// Arrange
var mockTodoService = new Mock <ITodoService>();
var mockTodoMapper = new Mock <ITodoModelDtoMapper>();
_ = mockTodoService.Setup(s => s.GetTodo(It.IsAny <Guid>()))
.ReturnsAsync(new TodoDto());
_ = mockTodoMapper.Setup(s => s.Map(It.IsAny <TodoDto>()))
.Returns(new TodoResponseModel());
var controller = new TodosController(mockTodoService.Object, mockTodoMapper.Object);
// Act
var result = await controller.Get(It.IsAny <Guid>());
// Assert
_ = result.Result.Should().BeOfType <OkObjectResult>();
var resultObject = result.GetObjectResult();
_ = resultObject.Should().BeOfType <TodoResponseModel>();
_ = resultObject.Should().NotBeNull();
mockTodoService.Verify(c => c.GetTodo(It.IsAny <Guid>()), Times.Once);
mockTodoMapper.Verify(c => c.Map(It.IsAny <TodoDto>()), Times.Once);
}
public void PostCommentStoresAndSetsDates()
{
//Given
var now = DateTime.Now;
var todosRepository = new TestTodosRepository {
Todos = new Dictionary <int, Todo> {
{ 5, new Todo {
Id = 5, TodoComments = new List <TodoComment>()
} }
}
};
var todosController = new TodosController(todosRepository);
var todoComment = new TodoComment {
Id = 1, Text = "A comment"
};
//When
var rc = todosController.PostComment(5, todoComment);
//Then
Assert.True(1 == rc.Count(), "Count is wrong");
Assert.True(5 == rc.First().Id, "Id is wrong");
Assert.True(1 == rc.First().TodoComments.First().Id, "TodoComment.Id is wrong");
Assert.True(now <= rc.First().TodoComments.First().UpdatedOn, "UpdatedOn should have been set");
Assert.True(5 == rc.First().TodoComments.First().TodoId, "TodoId is wrong");
}
public async Task CreateTodo_ValidData_ReturnsCreatedAtActionResult()
{
// Arrange
var createdTodoDTO = new CreatedTodoDTO();
var expectedTodoDTO = new TodoDTO()
{
Id = 1, Name = "Some Todo", IsComplete = true
};
var mockService = new Mock <ITodosService>();
mockService.Setup(ts => ts.CreateTodoAsync(createdTodoDTO)).ReturnsAsync(expectedTodoDTO);
var controller = new TodosController(mockService.Object);
// Action
var result = await controller.CreateTodo(createdTodoDTO);
// Assert
Assert.NotNull(result);
Assert.IsType <CreatedAtActionResult>(result.Result);
Assert.IsType <TodoDTO>(((CreatedAtActionResult)result.Result).Value);
var returnedResultTodo = (TodoDTO)((CreatedAtActionResult)result.Result).Value;
Assert.Equal(expectedTodoDTO.Id, returnedResultTodo.Id);
Assert.Equal(expectedTodoDTO.Name, returnedResultTodo.Name);
Assert.Equal(expectedTodoDTO.IsComplete, returnedResultTodo.IsComplete);
}
private void init()
{
mockLogger = new Mock <ILogger <TodosController> >();
mockServiceLogger = new Mock <ILogger <TodosService> >();
service = new TodosService(mockRepo.Object, mockServiceLogger.Object);
mockMapper = new Mock <IMapper>();
//var mappings = new MapperConfigurationExpression();
//mappings.AddProfile<DomainProfile>();
//Mapper.Initialize(mappings);
Mapper.Initialize(cfg => {
cfg.CreateMap <Todo, TodoView>();
cfg.CreateMap <TodoCategory, TodoCategoryView>();
cfg.CreateMap <TodoView, Todo>();
cfg.CreateMap <TodoCategoryView, TodoCategory>();
});
controller = new TodosController(mockMapper.Object, service, mockLogger.Object);
TodoCategory category = new TodoCategory(1, "Bevásárlás", 127);
TodoCategory category1 = new TodoCategory(2, "Teendõk", 156565);
testTodos.Add(new Todo(1, "Korte", category));
testTodos.Add(new Todo(2, "Szilva", category));
testTodos.Add(new Todo(3, "Kitakarítani", category1));
testTodos.ElementAt(0).Archived = true;
}
public TodosControllerTests()
{
_mockTodoRepository = new Mock <ITodoRepository>();
_objectUnderTest = new TodosController(_mockTodoRepository.Object);
_objectUnderTest.UserId = () => { return(_testUserId.ToString()); };
}
public void Todos_CanGetAllTodos()
{
// Arrange
var todoServiceMock = new Mock <TodosService>();
var todo = new Todo {
Id = 1, Title = "Mocked todo"
};
todoServiceMock.Setup(s => s.GetAll())
.Returns(new List <Todo> {
todo
})
.Verifiable();
var ctrl = new TodosController(todoServiceMock.Object);
// Act
var result = ctrl.Get() as ActionResult <List <Todo> >;
var data = result.Value as IEnumerable <Todo>;
// Assert
Assert.NotNull(data);
Assert.True(data.Any());
Assert.Equal(data.First().Title, todo.Title);
todoServiceMock.Verify();
}
public void Post_Creates_New_Todo()
{
var underTests = new TodosController();
var result = underTests.Post("Hello World");
// Assert.True(result.Value);
}
public void GET_Returns_List_Of_Todos()
{
var underTest = new TodosController();
var result = underTest.Get();
Assert.Equal(3, result.Value.Count());
}
public void Post_Creates_New_Todo()
{
var underTests = new TodosController();
var result = underTests.Post("I love Trump");
Assert.True(result.Value);
}
public void AlreadyDeletedReturnsNotFoundObjectResult()
{
using (var context = new TodosContext(_options))
{
var c = new TodosController(new TodosRepo(context));
var item = c.Delete(2);
Assert.True(item is NotFoundObjectResult);
}
}
public void canGetListfromController()
{
using (var context = new TodosContext(_options))
{
var c = new TodosController(new TodosRepo(context));
var list = c.Get();
Assert.AreEqual(1, list.Count());
}
}
public void TestDetailsView()
{
var controller = new TodosController();
var result = controller.Details(1) as ViewResult;
var thisTodo = (Todo)result.ViewData.Model;
Assert.AreEqual(1, thisTodo.ID);
// Trace.WriteLine(result);
}
public void CanDeleteTodo()
{
using (var context = new TodosContext(_options))
{
var c = new TodosController(new TodosRepo(context));
var viewitem = c.Delete(2);
var item = c.Get(2);
Assert.True(item is NotFoundResult);
}
}
public void Post_Increases_Todos_Count()
{
var underTest = new TodosController();
underTest.Post("Foo");
var result = underTest.Get();
Assert.Equal(4, result.Value.Count());
}
public void Index()
{
// Arrange
TodosController controller = new TodosController();
// Act
ViewResult result = controller.Index() as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void Read_Return_OkResult()
{
//Arrange
var controller = new TodosController(_todoItemService, null, null);
//Act
var data = controller.Read();
//Assert
Assert.IsType <OkObjectResult>(data);
}
public void Get_Empty_Todos_List()
{
const int USER_ID = 1;;
var initialTodos = new Dictionary <int, IEnumerable <Todo> >();
var todosRepository = new InMemoryTodosRepository(initialTodos);
var sut = new TodosController(todosRepository);
var result = sut.Get(USER_ID);
result.Result.Should().BeEmpty();
}
public static void Start(string url)
{
IWampHost host = new DefaultWampHost(url);
IWampHostedRealm realm = host.RealmContainer.GetRealmByName("realm1");
var todosController = new TodosController();
Task<IAsyncDisposable> registrationTask = realm.Services.RegisterCallee(todosController);
host.Open();
}
public void Update_InvalidId_BadRequest()
{
//Arrange
var controller = new TodosController(_todoItemService, null, null);
var id = Guid.Empty;
//Act
var updatedData = controller.Update(id, TestHelper.TodoItems.ElementAt(1));
//Assert
Assert.IsType <BadRequestObjectResult>(updatedData);
}
public void ReadById_Return_OkResult()
{
//Arrange
var controller = new TodosController(_todoItemService, null, null);
var id = TestHelper.TodoItems.ElementAt(0).Id;
//Act
var data = controller.Read(id);
//Assert
Assert.IsType <OkObjectResult>(data);
}
public void ReadById_Return_BadRequestResult()
{
//Arrange
var controller = new TodosController(_todoItemService, null, null);
var id = Guid.Empty;
//Act
var data = controller.Read(id);
//Assert
Assert.IsType <BadRequestObjectResult>(data);
}
public void Get()
{
// Arrange
setupContext();
TodosController controller = new TodosController(mockContext.Object);
// Act
IEnumerable <Todo> result = controller.Get();
// Assert
Assert.AreEqual(result.Count(), 3);
}
public void canAddTodo()
{
using (var context = new TodosContext(_options))
{
var c = new TodosController(new TodosRepo(context));
var list = c.Get();
var newid = list.Last().ID + 1;
var newitem = new Todos { ID = newid, Description = $"New item {newid}", IsComplete = false };
c.Put(newid, newitem);
int newcount = c.Get().Count();
Assert.AreEqual(newid, newcount);
}
}
public void TestTodosController()
{
using (var ctx = new mosheaContext(_options)) {
var c = new TodosController(ctx);
ctx.Todos.Add(new Todos {
Id = 1, Description = "test", Iscomplete = false
});
ctx.SaveChanges();
var all = c.Get();
Assert.AreEqual(1, all.Count());
Assert.AreEqual("test", all.ToList()[0].Description);
}
}
public void Delete()
{
// Arrange
setupContext();
TodosController controller = new TodosController(mockContext.Object);
// Act
controller.Delete(1);
// Assert
mockSet.Verify(m => m.Find(It.Is <int>(i => i == 1)), Times.Once());
mockSet.Verify(m => m.Remove(It.Is <Todo>(t => t.ID.Equals(1))), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
public void Put()
{
// Arrange
setupContext();
TodosController controller = new TodosController(mockContext.Object);
// Act
controller.Put(1);
// Assert
mockSet.Verify(m => m.Find(It.Is <int>(i => i == 1)), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
Assert.AreEqual(mockData.First().Completed, true);
}
public async Task CreateTodo_PayloadMissing_ReturnsBadRequest()
{
// Arrange
var mockService = new Mock <ITodosService>();
var controller = new TodosController(mockService.Object);
// Action
var result = await controller.CreateTodo(null);
// Assert
Assert.NotNull(result);
Assert.IsType <BadRequestObjectResult>(result.Result);
}
