public TodoViewModel(TodoService.Todo todo)
{
Id = todo.Id;
Erledigt = todo.Erledigt;
Name = todo.Name;
Dirty = false;
}
public Todo(TodoService.Todo todo)
{
Id = todo.Id;
Erledigt = todo.Erledigt;
Name = todo.Name;
LokalGeändert = false;
}
public async void CanGetTodoById()
{
using (var context = CreateContext())
{
var todoService = new TodoService(context);
var user = new User()
{
Email = "*****@*****.**", PasswordHash = "!@#QWE"
};
var todo1 = await todoService.Create("Test", "Test", user);
var todo2 = await todoService.Create("Test1", "Test1", user);
var getTodo = await todoService.GetById(todo2.Id);
Assert.Equal(getTodo, todo2);
}
}
public async Task AddTodoItem()
{
var todoItemForCreation = new TodoItemForCreationDto {
Text = TodoItemTextInput
};
if (String.IsNullOrWhiteSpace(todoItemForCreation.Text))
{
PlaceHolderText = "MUST ENTER SOME TEXT";
return;
}
HideModal();
await TodoService.AddTodoAsync(todoItemForCreation);
await OnTodoItemAdded.InvokeAsync(true);
}
public static void UpdateBadge()
{
System.Diagnostics.Debug.WriteLine("Hello From Quick update badge caller");
var type = BadgeTemplateType.BadgeNumber;
var xml = BadgeUpdateManager.GetTemplateContent(type);
var elements = xml.GetElementsByTagName("badge");
var element = elements[0] as Windows.Data.Xml.Dom.XmlElement;
var val = TodoService.GetMustDoList().Count;
element.SetAttribute("value", val.ToString());
var updator = BadgeUpdateManager.CreateBadgeUpdaterForApplication();
var notification = new BadgeNotification(xml);
updator.Update(notification);
}
public void DeleteTodo()
{
var options = new DbContextOptionsBuilder <TodoContext>()
.UseInMemoryDatabase(databaseName: "Add_writes_to_database")
.Options;
using (var context = new TodoContext(options))
{
var service = new TodoService(context);
TodoItem item = new TodoItem();
item.Name = "Go to store";
item.Id = 1;
item.IsComplete = false;
service.Create(item);
service.Delete(1);
Assert.Equal(0, context.TodoItems.ToList().Count);
}
}
public void CreateTodo_ShouldBeOkResult()
{
// Arrange
var options = GetTestDbOptions();
using (var context = new ApplicationContext(options))
{
User user = new User()
{
Id = 1,
FirstName = "Test",
LastName = "Moq",
Username = "******",
Role = "User"
};
Assignee assignee = new Assignee()
{
Email = "*****@*****.**",
Name = "Test Assignee",
};
context.Add <User>(user);
context.Add <Assignee>(assignee);
var todoService = new TodoService(context, GetMockMapper());
var todoDTO = new TodoDTO()
{
Name = "test1",
Description = "use mock",
UserId = 1,
AssigneeId = 1,
Done = false
};
var expected = new OkResult();
// Act
Task <IActionResult> actual = todoService.CreateTodo(todoDTO);
// Assert
Assert.IsNotNull(actual);
Assert.AreEqual(expected.GetType(), actual.Result.GetType());
}
}
public void UpdateTodo()
{
var options = new DbContextOptionsBuilder <TodoContext>()
.UseInMemoryDatabase(databaseName: "Add_writes_to_database")
.Options;
using (var context = new TodoContext(options))
{
var service = new TodoService(context);
TodoItem item = new TodoItem();
item.Name = "go to store";
item.Id = 1;
item.IsComplete = false;
service.Create(item);
TodoItem newItem = new TodoItem();
newItem.Name = "go to movies";
Assert.NotEqual(item, service.Update(1, newItem));
}
}
public IActionResult Put(TodoItem item)
{
/*TodoService todoService = new TodoService();
* var result = todoService.GetAllTodoItem().Where(m => m.id == item.id)
* .Select(c => {
* c.summary = item.summary;
* c.temperatureC = item.temperatureC;
* c.temperatureF = item.temperatureF;
* return c;
* });*/
///TODO: Get a list with new result?
//return Ok(result);
TodoService todoService = new TodoService();
return(todoService.UpdateTodoItem(item));
}
public async Task GetAllAsync_Should_ReturnAllTodos()
{
//Setup DbContext and DbSet mock
var dbContextMock = new Mock <ITodoContext>();
var testTodos = GetTestTodos();
var todoDbSetMock = testTodos.AsQueryable().GetMockDbSet();
dbContextMock.Setup(x => x.DbSet <Todo>()).Returns(todoDbSetMock.Object);
//Execute
var todoService = new TodoService(dbContextMock.Object);
var todos = await todoService.GetAllAsync <Todo>();
//Assert
Assert.IsAssignableFrom <IEnumerable <Todo> >(todos);
Assert.Equal(2, todos.Count);
}
protected void PopulateTable()
{
if (tasks == null)
{
tasks = new List <Todo> ();
}
// make the CloudMine call via service (aync) and add the sections
TodoService.GetTodos().ContinueWith(res => {
tasks = res.Result.Success.Values.ToList();
var rows = from t in tasks
select(Element) new StringElement((t.Name == "" ? "<new task>" : t.Name), t.Notes);
var s = new Section();
s.AddAll(rows);
Root = new RootElement("Tasky")
{
s
};
});
}
public async void CanGetAllTodosByUserId()
{
using (var context = CreateContext())
{
var todoService = new TodoService(context);
var user = new User()
{
Email = "*****@*****.**", PasswordHash = "!@#QWE"
};
await todoService.Create("Test", "Test", user);
await todoService.Create("Test1", "Test1", user);
var todos = todoService.GetAll(user.Id);
Assert.Equal(2, todos.Count);
}
}
private static async Task Start()
{
var todoService = new TodoService();
// Get all Todos
// var todos = await todoService.GetAll();
// todos.ForEach(todo => Console.WriteLine(todo.Title));
// Save Todo
var newTodo = new TodoModel()
{
Title = "Teste",
Completed = false,
UserId = 1
};
var savedTodo = await todoService.Save(newTodo);
Console.WriteLine(savedTodo.Id);
}
public async Task ReturnTasksAndEvents_WithoutOverdueTasks()
{
var dueDateTime = DateTime.Today;
bool includeOverdueTasks = false;
_eventsClientMock.Setup(x => x.GetEvents(dueDateTime, It.IsAny <string>(), false))
.Returns(Task.FromResult(TestDataHelper.Events));
_tasksClientMock.Setup(x => x.GetTasks(dueDateTime, includeOverdueTasks, It.IsAny <string>()))
.Returns(Task.FromResult(TestDataHelper.Tasks));
ITodoService service = new TodoService(_eventsClientMock.Object, _tasksClientMock.Object, _loggerMock.Object);
var request = GetTodosRequest(dueDateTime, includeOverdueTasks);
var result = await service.GetTodos(request);
Assert.Equal(TestDataHelper.Tasks.Value.First().Subject, result.Value.Tasks.First().Subject);
Assert.Equal(TestDataHelper.Events.Value.First().Subject, result.Value.Events.First().Subject);
}
public async Task DeleteTodo_Is_Ok()
{
// Arrange
var mockTodoRepository = new Mock <ITodoRepository>();
var mockTodoMapper = new Mock <ITodoDtoEntityMapper>();
_ = mockTodoRepository.Setup(s => s.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(new TodoEntity());
_ = mockTodoRepository.Setup(s => s.DeleteAsync(It.IsAny <TodoEntity>()));
var service = new TodoService(mockTodoRepository.Object, mockTodoMapper.Object);
// Act
await service.DeleteTodo(It.IsAny <Guid>());
// Assert
mockTodoRepository.Verify(c => c.GetByIdAsync(It.IsAny <Guid>()), Times.Once);
mockTodoRepository.Verify(c => c.DeleteAsync(It.IsAny <TodoEntity>()), Times.Once);
}
private static async Task GetTodoAsync(string id = null)
{
if (id == null)
{
Console.Write("Enter The Id for the Todo:");
id = Console.ReadLine();
//return id;
}
var todo = await TodoService.GetTodoAsync(id);
Console.WriteLine($"Id: {todo.Id}");
Console.WriteLine($"Created: {todo.Created}");
Console.WriteLine($"Completed: {todo.Completed}");
Console.WriteLine($"Activity: {todo.Activity}");
Console.WriteLine(new string('-', 30));
}
public async Task DeleteTodo_Is_Null()
{
// Arrange
var mockTodoRepository = new Mock <ITodoRepository>();
var mockTodoMapper = new Mock <ITodoDtoEntityMapper>();
mockTodoRepository.Setup(s => s.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync((TodoEntity)null);
mockTodoRepository.Setup(s => s.DeleteAsync(It.IsAny <TodoEntity>()));
var service = new TodoService(mockTodoRepository.Object, mockTodoMapper.Object);
// Act
var result = await service.DeleteTodo(It.IsAny <Guid>());
// Assert
result.Should().BeNull();
mockTodoRepository.Verify(c => c.GetByIdAsync(It.IsAny <Guid>()), Times.Once);
mockTodoRepository.Verify(c => c.DeleteAsync(It.IsAny <TodoEntity>()), Times.Never);
}
public async void CreateAddsNewTodo()
{
mockTodoRepository
.Setup(r => r.Add(It.IsAny <Todo>()))
.Returns((Todo newItem) =>
{
todoItems.Add(newItem);
return(Task.CompletedTask);
});
mockTodoRepository.VerifyNoOtherCalls();
var serviceToTest = new TodoService(mockTodoRepository.Object);
var newTodo = new Todo {
Title = "Check"
};
await serviceToTest.Create(newTodo);
Assert.Contains(todoItems, t => t.Title == newTodo.Title);
}
public async Task GetAsync_Should_ReturnTodo()
{
//Setup DbContext and DbSet mock
var dbContextMock = new Mock <ITodoContext>();
var testTodoId = 1;
var testTodos = GetTestTodos();
var todoDbSetMock = testTodos.AsQueryable().GetMockDbSet();
dbContextMock.Setup(x => x.DbSet <Todo>()).Returns(todoDbSetMock.Object);
//Execute
var todoService = new TodoService(dbContextMock.Object);
var todo = await todoService.GetAsync <Todo>(x => x.TodoId == testTodoId);
//Assert
Assert.IsAssignableFrom <Todo>(todo);
}
public async Task GetAllTodos_ReturnsTodosList_WhenRepositoryReturnsTodosList()
{
// Arrange
var mockRepositoryResponse = new List <BusinessModels.Todo>()
{
new BusinessModels.Todo()
{
Id = Guid.Parse("e0f36c5f-7b2d-45bd-a646-8bb1198879ae"),
Name = "ToDo1"
},
new BusinessModels.Todo()
{
Id = Guid.Parse("a7f01520-537d-47fb-afbf-796607e95701"),
Name = "ToDo2"
}
};
_todoRepositoryMock.Setup(s => s.GetAllTodos()).ReturnsAsync(mockRepositoryResponse);
var expectedServiceResponse = new List <BusinessModels.Todo>()
{
new BusinessModels.Todo()
{
Id = Guid.Parse("e0f36c5f-7b2d-45bd-a646-8bb1198879ae"),
Name = "ToDo1"
},
new BusinessModels.Todo()
{
Id = Guid.Parse("a7f01520-537d-47fb-afbf-796607e95701"),
Name = "ToDo2"
}
};
var unitUnderTest = new TodoService(_todoRepositoryMock.Object);
// Act
var response = await unitUnderTest.GetAllTodos();
//Assert
response.Should().BeEquivalentTo(expectedServiceResponse);
}
public async Task <IActionResult> Index(string sortBy, int page = 1)
{
const int PageSize = 15;
List <Todo> todos = await TodoService.GetAllAsync(sortBy);
int count = todos.Count;
List <Todo> paginatedTodos = todos.Skip((page - 1) * PageSize).Take(PageSize).ToList();
this.ViewBag.MaxPage = (count / PageSize) - (count % PageSize == 0 ? 1 : 0);
this.ViewBag.Page = page;
List <TodoType> todoTypes = await TodoTypeService.GetAllAsync();
IndexViewModel model = new IndexViewModel {
Todos = paginatedTodos, TodoTypes = todoTypes
};
return(View(model));
}
public async Task GetTodo_Is_Ok()
{
// Arrange
var mockTodoRepository = new Mock <ITodoRepository>();
var mockTodoMapper = new Mock <ITodoDtoEntityMapper>();
_ = mockTodoRepository.Setup(s => s.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(new TodoEntity());
_ = mockTodoMapper.Setup(s => s.Map(It.IsAny <TodoEntity>()))
.Returns(new TodoDto());
var service = new TodoService(mockTodoRepository.Object, mockTodoMapper.Object);
// Act
var result = await service.GetTodo(It.IsAny <Guid>());
// Assert
_ = result.Should().BeOfType <TodoDto>();
mockTodoRepository.Verify(c => c.GetByIdAsync(It.IsAny <Guid>()), Times.Once);
mockTodoMapper.Verify(c => c.Map(It.IsAny <TodoEntity>()), Times.Once);
}
public void SaveTodo()
{
if (EditTodoModel.Caption == null || EditTodoModel.Caption.IsNullOrWhiteSpace() ||
EditTodoModel.Content == null || EditTodoModel.Content.IsNullOrWhiteSpace() ||
EditTodoModel.EstimatedHours <= 0)
{
MessageBox.Show(
$"Проверьте правильность введенных данных.",
"Ошибка сохранения", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
return;
}
if (EditTodoModel.Owner == null)
{
MessageBox.Show(
$"Необходимо назначить исполнителя для текущей задачи.",
"Ошибка сохранения", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
return;
}
if (_isEditExistRecord)
{
TodoService.UpdateTodo(Mapper.Map <TodoModel, TodoDTO>(EditTodoModel), EditTodoModel.Owner);
_isEditExistRecord = false;
}
else
{
TodoService.CreateTodo(CurrentProject.ProjectInfoId, Mapper.Map <TodoModel, TodoDTO>(EditTodoModel),
EditTodoModel.Owner);
}
NotifyOfPropertyChange(() => CountAllTodo);
UpdateData();
IsEditNow = false;
EditTodoModel = SelectedItem;
}
public static void Main(string[] args)
{
const int PORT = 5000;
var todoImplement = new TodoImplement(new UnitOfWork());
var server = new Server
{
Services =
{
TodoService.BindService(todoImplement)
},
Ports = { new ServerPort("0.0.0.0", PORT, ServerCredentials.Insecure) }
};
server.Start();
Console.WriteLine("gRPC Todo server listening on port " + PORT);
Console.WriteLine("Press any key to stop the server...");
Console.Read();
server.ShutdownAsync().Wait();
// CreateWebHostBuilder(args).Build().Run();
}
public async Task AddOrUpdateSettingsAsync_AddSettingValue_ShouldBeSave()
{
var repository = _fixture.CreateRepository <TodoItem>();
var items = await Setup(repository, new [] { "a" }, new[] { "a" });
var settingRepository = repository.GetRepository <TodoItemSettings>();
var service = new TodoService(Mapper, settingRepository);
var todoId = items.ElementAt(0).TodoId;
var changes = await service.AddOrUpdatePropsAsync(todoId,
new TodoItemSettingDto
{
Name = "Name",
IsCompleted = true,
Description = "Description",
ExpireDate = DateTime.MinValue
});
changes.Should().BeGreaterThan(0);
}
public void CanSetPercentATodo()
{
// setup
var options = new DbContextOptionsBuilder <TodoContext>()
.UseInMemoryDatabase(databaseName: "TodoDb7")
.Options;
using (var context = new TodoContext(options))
{
context.Todos.Add(new Todo {
Title = "Test Todo 1", Description = "Description Todo 1"
});
context.Todos.Add(new Todo {
Title = "Test Todo 2", Description = "Description Todo 2"
});
context.Todos.Add(new Todo {
Title = "Test Todo 3", Description = "Description Todo 3"
});
context.Todos.Add(new Todo {
Title = "Test Todo 4", Description = "Description Todo 4"
});
context.Todos.Add(new Todo {
Title = "Test Todo 5", Description = "Description Todo 5"
});
context.SaveChanges();
}
// operation
var todoService = new TodoService(new TodoContext(options));
var result = todoService.SetTodoPercentComplete(new SetTodoPercentCompleteDto
{
Id = 1,
PercentComplete = 90
});
// assert
Assert.AreEqual(1, result.Id);
Assert.AreEqual(90, result.PercentComplete);
}
public async Task UpdateAsync_Should_UpdateTodo()
{
//Setup DbContext and DbSet mock
var dbContextMock = new Mock <ITodoContext>();
var testTodo = new Todo
{
TodoId = 2,
Title = "updated",
Points = new List <TodoPoint> {
}
};
var testTodos = GetTestTodos();
var todoBefore = testTodos.Where(x => x.TodoId == testTodo.TodoId).FirstOrDefault();
string todoTitle = todoBefore.Title;
var todoDbSetMock = testTodos.AsQueryable().GetMockDbSet();
dbContextMock.Setup(x => x.DbSet <Todo>()).Returns(todoDbSetMock.Object);
todoDbSetMock.Setup(x => x.Update(It.IsAny <Todo>()))
.Callback(() =>
{
var todo = testTodos.Where(x => x.TodoId == testTodo.TodoId).FirstOrDefault();
todo.Title = testTodo.Title;
});
//Execute
var todoService = new TodoService(dbContextMock.Object);
await todoService.UpdateAsync(testTodo);
var todoAfter = await todoService.GetAsync <Todo>(x => x.TodoId == testTodo.TodoId);
//Assert
Assert.NotEqual(todoTitle, todoBefore.Title);
Assert.IsAssignableFrom <Todo>(todoAfter);
Assert.Equal(testTodo.Title, todoAfter.Title);
}
public void TestTodoService_GetAll_ShouldCallFindAllRepositoryAndAutoMapper()
{
// Arrange
var expectedTodos = new TodoModel[] { };
Mock <IRepository <TodoModel> > todoRepository = new Mock <IRepository <TodoModel> >();
todoRepository.Setup(x => x.FindAll())
.Returns(expectedTodos.AsQueryable());
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(m => m.Map <IEnumerable <Todo> >(It.IsAny <IEnumerable <TodoModel> >()))
.Returns(It.IsAny <IEnumerable <Todo> >());
var cacheMock = new Mock <ICacheProvider>();
var todoService = new TodoService(todoRepository.Object, mapperMock.Object, cacheMock.Object);
// Act
var results = todoService.GetAllData();
// Assert
todoRepository.Verify(x => x.FindAll(), Times.Once);
mapperMock.Verify(x => x.Map <IEnumerable <Todo> >(It.IsAny <IEnumerable <TodoModel> >()), Times.Once);
}
public void TestTodoService_Store_ShouldCallAddRepositoryAndAutoMapper()
{
// Arrange
// mock repository
Mock <IRepository <TodoModel> > todoRepository = new Mock <IRepository <TodoModel> >();
todoRepository.Setup(repo => repo.Add(It.IsAny <TodoModel>()));
// mock automapper
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(m => m.Map <TodoModel>(It.IsAny <Todo>()))
.Returns(It.IsAny <TodoModel>());
var cacheMock = new Mock <ICacheProvider>();
var todoService = new TodoService(todoRepository.Object, mapperMock.Object, cacheMock.Object);
// Act
todoService.Store(It.IsAny <Todo>());
// Assert
todoRepository.Verify(x => x.Add(It.IsAny <TodoModel>()), Times.Once);
mapperMock.Verify(x => x.Map <TodoModel>(It.IsAny <Todo>()), Times.Once);
}
public async void GetTodo_Maps_Model_Correctly()
{
// Arrange
var todoRepository = Substitute.For <ITodoRepository>();
var todoService = new TodoService(todoRepository);
var entity = new FS.Todo.Data.Entities.Todo
{
Id = Guid.NewGuid(),
Description = "test todo entity",
IsCompleted = false,
};
todoRepository.FindAsync(entity.Id).Returns(entity);
// Act
var todoModel = await todoService.GetTodoAsync(entity.Id);
// Assert
Assert.Equal(entity.Id, todoModel.Id);
Assert.Equal(entity.Description, todoModel.Description);
Assert.Equal(entity.IsCompleted, todoModel.IsCompleted);
}
public async void CanUpdateExistingTodo()
{
using (var context = CreateContext())
{
var todoService = new TodoService(context);
var user = new User()
{
Email = "*****@*****.**", PasswordHash = "!@#QWE"
};
var todo = await todoService.Create("Test", "Test", user);
todo.Title = "Test Updated";
todo.IsComplete = true;
var result = await todoService.Update(todo);
var updated = await todoService.GetById(todo.Id);
Assert.Equal(1, result);
Assert.Equal("Test Updated", updated.Title);
Assert.True(updated.IsComplete);
}
}
public async Task TestUpdateTodoItemAsync()
{
// Arrange
var dbContext = DbContextMocker.GetTodoDbContext();
var todoService = new TodoService(dbContext);
var request = new TodoItemViewModel
{
Id = 1,
Title = "unit test title",
Description = "unit test description",
Latitude = -121.23126,
Longitude = 42.6235675
};
// Act
var result = todoService.UpdateTodoItem(request);
dbContext.Dispose();
// Assert
Assert.Equal(1, result);
}
