public string Get(int todoItemId)
{
var data = _todoItemsProvider.GetById(todoItemId);
var dto = new ToDoItemDto(data);
return(dto.Serialize());
}
public async Task When_invoking_get_async_it_should_invoke_get_async_on_repository()
{
//Arrange
var todoItem = new ToDoItem
{
Text = "Sample text",
IsCompleted = true
};
var toDoItemDto = new ToDoItemDto
{
Id = todoItem.Id,
Text = todoItem.Text,
IsCompleted = todoItem.IsCompleted,
CreatedAt = todoItem.CreatedAt
};
var todoRepositoryMock = new Mock <IRepository <ToDoItem> >();
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(x => x.Map <ToDoItemDto>(todoItem));
var itemService = new ToDoItemService(todoRepositoryMock.Object, mapperMock.Object);
todoRepositoryMock.Setup(x => x.GetById(todoItem.Id)).ReturnsAsync(todoItem);
//Act
var existToDoItemDto = await itemService.GetById(todoItem.Id);
//Assert
todoRepositoryMock.Verify(x => x.GetById(todoItem.Id), Times.Once());
toDoItemDto.Should().NotBeNull();
toDoItemDto.Text.Should().BeEquivalentTo(todoItem.Text);
toDoItemDto.IsCompleted.Should().Be(todoItem.IsCompleted);
todoItem.Id.Should().Be(todoItem.Id);
}
public async Task UpdateToDoItem()
{
ToDoItemDto updatedToDoItem = await _toDoItemRepository.Update(new UpdateToDoItemDto { ToDoItemId = 2, Description = "sell phone", UserId = 1, LabelId = 1, ToDoListId = 1 });
Assert.IsNotNull(updatedToDoItem);
Assert.AreEqual("sell phone", updatedToDoItem.Description);
}
public async Task AddToDoItem()
{
ToDoItemDto addedToDoItem = await _toDoItemRepository.Add(new CreateToDoItemDto { Description = "buy phone", CreatedBy = 1, ToDoListId = 1, UserId = 1, LabelId = 1, IsActive = true });
Assert.IsNotNull(addedToDoItem);
Assert.AreEqual("buy phone", addedToDoItem.Description);
}
public async Task <ActionResult <ToDoItem> > UpdateTask(int id, ToDoItemDto toDoItemDto)
{
if (ModelState.IsValid)
{
var toDoItem = await _toDoContext.ToDoItems.FindAsync(id);
if (toDoItem != null)
{
toDoItem.DueDate = toDoItemDto.DueDate;
toDoItem.Label = toDoItemDto.Label;
toDoItem.Status = toDoItemDto.Status;
toDoItem.ToDo = toDoItemDto.ToDo;
toDoItem.DueDate = toDoItemDto.DueDate;
toDoItem.UpdateDt = DateTime.UtcNow;
_toDoContext.Attach(toDoItem);
_toDoContext.Entry(toDoItem).State = EntityState.Modified;
var output = await _toDoContext.SaveChangesAsync();
if (output > 0)
{
return(Ok(toDoItem));
}
}
return(BadRequest("Item not found"));
}
return(BadRequest("Some error happened"));
}
public async Task UpdateToDoItemToDoGroupIdIsNotSupportedTest()
{
using (ToDoLineTestEnv testEnv = new ToDoLineTestEnv())
{
var(userName, client) = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
ToDoItemDto toDoItem = await client.Controller <ToDoItemsController, ToDoItemDto>()
.Set(new ToDoItemDto {
Title = "Task1", Notes = "Hi this is the first sample", ToDoGroupId = null
})
.InsertEntryAsync();
toDoItem.Title += "!";
toDoItem.IsCompleted = true;
toDoItem.ToDoGroupId = Guid.NewGuid();
try
{
await client.Controller <ToDoItemsController, ToDoItemDto>()
.Key(toDoItem.Id)
.Set(toDoItem)
.UpdateEntryAsync();
Assert.Fail();
}
catch (WebRequestException exp) when(exp.Message == "KnownError" && JToken.Parse(exp.Response)["error"]["message"].Value <string>() == "ChangingToDoGroupIdIsNotSupportedAtTheMoment")
{
}
}
}
public async Task UpdateToDoItemTest()
{
ToDoItemDto result = await _ToDoItemContract.UpdateToDoItem(new UpdateToDoItemDto());
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ToDoItemId);
}
public async Task ActiveShowInMyDayToDoItemTest()
{
using ToDoLineTestEnv testEnv = new ToDoLineTestEnv(new TestEnvironmentArgs
{
AdditionalDependencies = (dependencyManager, services) =>
{
IDateTimeProvider dateTimeProvider = A.Fake <IDateTimeProvider>();
A.CallTo(() => dateTimeProvider.GetCurrentUtcDateTime())
.Returns(new DateTimeOffset(2018, 1, 1, 10, 10, 10, TimeSpan.Zero));
dependencyManager.RegisterInstance(dateTimeProvider);
}
});
ToDoLineClient toDoLineClient = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
UserDto user = await toDoLineClient.ODataClient.GetUserByUserName(toDoLineClient.UserName);
ToDoGroupDto toDoGroup = await toDoLineClient.ODataClient.ToDoGroups()
.CreateToDoGroup("Test")
.ExecuteAsSingleAsync();
ToDoItemDto toDoItem = await toDoLineClient.ODataClient.ToDoItems()
.Set(new ToDoItemDto {
Title = "Task1", Notes = "Hi this is the first sample", ShowInMyDay = true, ToDoGroupId = toDoGroup.Id
})
.InsertEntryAsync();
Assert.AreEqual("Task1", toDoItem.Title);
Assert.AreEqual(true, toDoItem.ShowInMyDay);
}
public async Task UpdateToDoItemTest()
{
using ToDoLineTestEnv testEnv = new ToDoLineTestEnv();
ToDoLineClient toDoLineClient = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
ToDoGroupDto toDoGroup = await toDoLineClient.ODataClient.ToDoGroups()
.CreateToDoGroup("Test")
.ExecuteAsSingleAsync();
ToDoItemDto toDoItem = await toDoLineClient.ODataClient.ToDoItems()
.Set(new ToDoItemDto {
Title = "Task1", Notes = "Hi this is the first sample", ToDoGroupId = toDoGroup.Id
})
.InsertEntryAsync();
toDoItem.Title += "!";
toDoItem.IsCompleted = true;
ToDoItemDto updatedToDoItem = await toDoLineClient.ODataClient.ToDoItems()
.Key(toDoItem.Id)
.Set(toDoItem)
.UpdateEntryAsync();
Assert.AreEqual("Task1!", updatedToDoItem.Title);
Assert.AreEqual(true, updatedToDoItem.IsCompleted);
Assert.AreEqual(toDoLineClient.UserName, updatedToDoItem.CompletedBy);
}
private List <string> ValidateInputParameters(ToDoItemDto dto)
{
var errors = new List <string>();
if (dto == null)
{
errors.Add("Модель не может быть пустой");
return(errors);
}
if (string.IsNullOrWhiteSpace(dto.Title))
{
errors.Add("Тема должна быть заполнена");
}
if (dto.StartDate.HasValue && dto.StartDate < DateTime.MinValue)
{
errors.Add("Не заполнена или заполнена неправильно дата начала действия");
}
if (dto.EndDate.HasValue && !dto.StartDate.HasValue)
{
errors.Add("Если есть дата начала, то необходима и дата окончания");
}
if (dto.EndDate.HasValue && (dto.EndDate > DateTime.MaxValue || dto.EndDate < DateTime.MinValue || dto.EndDate < dto.StartDate))
{
errors.Add("Неправильно заполнена дата окончания действия");
}
return(errors);
}
public IResult Update(ToDoItemDto model)
{
var entity = _mapper.Map <ToDoItem>(model);
_toDoItemDal.Update(entity);
return(new SuccessResult());
}
public async Task AddTest()
{
ToDoItemDto result = await _ToDoItemService.Add(new CreateToDoItemDto());
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ToDoItemId);
}
public async Task GetByIdTest()
{
ToDoItemDto result = await _ToDoItemService.GetById(1, 1);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ToDoItemId);
}
public async Task UpdateTest()
{
ToDoItemDto result = await _ToDoItemService.Update(new UpdateToDoItemDto());
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ToDoItemId);
}
public async Task GetToDoItemById()
{
ToDoItemDto result = await _ToDoItemContract.GetToDoItemById(1, 1);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ToDoItemId);
}
public async Task UpdateToDoItem()
{
ToDoItemDto updatedToDoItem = await _toDoItemDbOps.UpdateToDoItem(new UpdateToDoItemDto { ToDoItemId = 2, Notes = "sell phone" });
Assert.IsNotNull(updatedToDoItem);
Assert.AreEqual("sell phone", updatedToDoItem.Notes);
}
public async Task UpdateToDoItemTest()
{
using (ToDoLineTestEnv testEnv = new ToDoLineTestEnv())
{
var(userName, client) = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
ToDoGroupDto toDoGroup = await client.Controller <ToDoGroupsController, ToDoGroupDto>()
.Action(nameof(ToDoGroupsController.CreateToDoGroup))
.Set(new ToDoGroupsController.CreateToDoGroupArgs {
title = "Test"
})
.ExecuteAsSingleAsync();
ToDoItemDto toDoItem = await client.Controller <ToDoItemsController, ToDoItemDto>()
.Set(new ToDoItemDto {
Title = "Task1", Notes = "Hi this is the first sample", ToDoGroupId = toDoGroup.Id
})
.InsertEntryAsync();
toDoItem.Title += "!";
toDoItem.IsCompleted = true;
ToDoItemDto updatedToDoItem = await client.Controller <ToDoItemsController, ToDoItemDto>()
.Key(toDoItem.Id)
.Set(toDoItem)
.UpdateEntryAsync();
Assert.AreEqual("Task1!", updatedToDoItem.Title);
Assert.AreEqual(true, updatedToDoItem.IsCompleted);
Assert.AreEqual(userName, updatedToDoItem.CompletedBy);
}
}
public async Task AddToDoItem()
{
ToDoItemDto addedToDoItem = await _toDoItemDbOps.AddToDoItem(new CreateToDoItemDto { Notes = "buy phone", CreatedBy = 1, ToDoListId = 1 });
Assert.IsNotNull(addedToDoItem);
Assert.AreEqual("buy phone", addedToDoItem.Notes);
}
public ActionResult Get(int todoItemId)
{
var data = _todoItemsProvider.GetById(todoItemId);
var dto = new ToDoItemDto(data);
return(Json(dto));
}
public ToDoItemDto Create(ToDoItemDto todoItem)
{
var todoModel = todoItem.Adapt <ToDoItemModel>();
var result = _toDoRepository.Create(todoModel).Adapt <ToDoItemDto>();
return(result);
}
public async Task CreatingToDoItemShouldCreateToDoItemOptionsPerUserTest()
{
using ToDoLineTestEnv testEnv = new ToDoLineTestEnv();
ToDoLineClient toDoLineClient1 = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
ToDoGroupDto toDoGroup = await toDoLineClient1.ODataClient.ToDoGroups()
.CreateToDoGroup("Test")
.ExecuteAsSingleAsync();
ToDoLineClient toDoLineClient2 = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
UserDto user2 = await toDoLineClient1.ODataClient.GetUserByUserName(toDoLineClient2.UserName);
await toDoLineClient1.ODataClient.ToDoGroups()
.ShareToDoGroupWithAnotherUser(anotherUserId: user2.Id, toDoGroupId: toDoGroup.Id)
.ExecuteAsync();
ToDoItemDto toDoItem = await toDoLineClient2.ODataClient.ToDoItems()
.Set(new ToDoItemDto {
Title = "Task1", Notes = "Hi this is the first sample", ToDoGroupId = toDoGroup.Id
})
.InsertEntryAsync();
bool hasToDoItem = (await toDoLineClient1.ODataClient.ToDoItems()
.GetMyToDoItems()
.FindEntriesAsync()).Any();
Assert.AreEqual(true, hasToDoItem);
}
public async Task <IActionResult> Patch([Required] int id, [FromBody] JsonPatchDocument <UpdateToDoItemDto> toDoItemPatch)
{
int userId = int.Parse(HttpContext.Items["UserId"].ToString());
if (toDoItemPatch == null)
{
return(BadRequest(
new ResponseModel <string>
{
IsSuccess = false,
Result = "Bad Request.",
Message = "Invalid request, Mandatory fields not provided in request."
}));
}
ToDoItemDto existingToDoItemDto = await _itemService.GetById(id, userId);
if (existingToDoItemDto == null)
{
return(NotFound(
new ResponseModel <string>
{
IsSuccess = false,
Result = "No existing record found for provided input.",
Message = "No data exist for Id = " + id
}));
}
var existingUpdateToDoItemDto = _mapper.Map <UpdateToDoItemDto>(existingToDoItemDto);
toDoItemPatch.ApplyTo(existingUpdateToDoItemDto);
bool isValid = TryValidateModel(existingToDoItemDto);
if (!isValid)
{
return(BadRequest(ModelState));
}
existingUpdateToDoItemDto.UserId = userId;
existingUpdateToDoItemDto.ModifiedBy = userId;
ToDoItemDto updatedToDoItemDto = await _itemService.Update(existingUpdateToDoItemDto);
if (updatedToDoItemDto == null)
{
return(NotFound(
new ResponseModel <string>
{
IsSuccess = false,
Result = "No existing record found for provided input.",
Message = "No data exist for Id = " + id
}));
}
else
{
return(Ok(
new ResponseModel <ToDoItemDto>
{
IsSuccess = true,
Result = updatedToDoItemDto,
Message = "ToDoItem with Id = " + updatedToDoItemDto.ToDoItemId + " is updated on " + updatedToDoItemDto.ModifiedOn + " by UserId = " + userId + "."
}));
}
}
public IHttpActionResult Create([FromBody] ToDoItemDto item)
{
item.Id = ToDoRepo.Count + 1;
ToDoRepo.Add(item);
return(this.Ok(item));
}
public async Task <IActionResult> CompleteAsync(int id)
{
var toDoItem = await _repository.GetByIdAsync <ToDoItem>(id);
toDoItem.MarkComplete();
await _repository.UpdateAsync(toDoItem);
return(Ok(ToDoItemDto.FromToDoItem(toDoItem)));
}
/// <summary>
/// Adds ToDoItem record
/// </summary>
/// <param name="createToDoItemDto"></param>
/// <returns> added ToDoList record. </returns>
public async Task <ToDoItemDto> AddToDoItem(CreateToDoItemDto createToDoItemDto)
{
if (createToDoItemDto != null)
{
createToDoItemDto.CreatedBy = _userId;
}
ToDoItemDto addedItem = await _toDoItemDbOps.AddToDoItem(createToDoItemDto);
return(addedItem);
}
public async Task <IActionResult> PostAsync([FromBody] ToDoItemDto item)
{
var todoItem = new ToDoItem()
{
Title = item.Title,
Description = item.Description
};
await _repository.AddAsync(todoItem);
return(Ok(ToDoItemDto.FromToDoItem(todoItem)));
}
public async Task <ActionResult <ToDoItemDto> > CreateToDoItem(ToDoItemDto todoItemDto)
{
var todoItem = new ToDoItem
{
IsComplete = todoItemDto.IsComplete,
Name = todoItemDto.Name
};
_context.ToDoItems.Add(todoItem);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetToDoItem), new { id = todoItemDto.Id }, ItemToDTO(todoItem)));
}
public async Task KickingUserFromToDoGroupShouldRemoveItsToDoItemsTest()
{
using (ToDoLineTestEnv testEnv = new ToDoLineTestEnv())
{
var(userName1, client1) = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
var(userName2, client2) = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
//create ToDoGroup by first user
ToDoGroupDto toDoGroup = await client1.Controller <ToDoGroupsController, ToDoGroupDto>()
.Action(nameof(ToDoGroupsController.CreateToDoGroup))
.Set(new ToDoGroupsController.CreateToDoGroupArgs {
title = "Group1"
})
.ExecuteAsSingleAsync();
ToDoItemDto toDoItem = await client1.Controller <ToDoItemsController, ToDoItemDto>()
.Set(new ToDoItemDto {
Title = "Test1", ToDoGroupId = toDoGroup.Id
})
.InsertEntryAsync();
UserDto user2 = await client1.GetUserByUserName(userName2);
await client1.Controller <ToDoGroupsController, ToDoGroupDto>()
.Action(nameof(ToDoGroupsController.ShareToDoGroupWithAnotherUser))
.Set(new ToDoGroupsController.ShareToDoGroupWithAnotherUserArgs {
anotherUserId = user2.Id, toDoGroupId = toDoGroup.Id
})
.ExecuteAsSingleAsync();
await client1.Controller <ToDoGroupsController, ToDoGroupDto>()
.Action(nameof(ToDoGroupsController.KickUserFromToDoGroup))
.Set(new ToDoGroupsController.KickAnotherUserFromMyToDoGroupArge {
userId = user2.Id, toDoGroupId = toDoGroup.Id
})
.ExecuteAsSingleAsync();
ToDoGroupDto toDoGroupK = await client1.Controller <ToDoGroupsController, ToDoGroupDto>()
.Function(nameof(ToDoGroupsController.GetMyToDoGroups))
.Filter(tdg => toDoGroup.Id == tdg.Id)
.FindEntryAsync();
bool hasToDoItem = (await client2.Controller <ToDoItemsController, ToDoItemDto>()
.Function(nameof(ToDoItemsController.GetMyToDoItems))
.FindEntriesAsync()).Any();
Assert.AreEqual(1, toDoGroupK.SharedByCount);
Assert.AreEqual(false, hasToDoItem);
}
}
public void Update(ToDoItem toDoItem)
{
var maxId = _context.ToDoItems.Max(p => p.Id);
var toDoItemDto = new ToDoItemDto()
{
Id = maxId + 1,
Created = toDoItem.Created,
Description = toDoItem.Description,
IsDone = toDoItem.IsDone
};
_context.ToDoItems.Update(toDoItemDto);
_context.SaveChanges();
}
public async Task CreateToDoItemWithoutToDoGroupTest()
{
using ToDoLineTestEnv testEnv = new ToDoLineTestEnv();
ToDoLineClient toDoLineClient = await testEnv.LoginInToApp(registerNewUserByRandomUserName : true);
ToDoItemDto toDoItem = await toDoLineClient.ODataClient.ToDoItems()
.Set(new ToDoItemDto {
Title = "Task1", Notes = "Hi this is the first sample", ToDoGroupId = null
})
.InsertEntryAsync();
Assert.AreEqual("Task1", toDoItem.Title);
}
