public async Task <IActionResult> UpdateItem(int id, [FromBody] SaveItemResource saveItemResource)
{
var currentItem = await _itemService.GetItemById(id);
if (currentItem == null)
{
return(NotFound());
}
bool IsValid = await CheckIfUserIsItemSeller(id);
if (!IsValid)
{
return(Unauthorized());
}
var validator = new SaveItemResourceValidator();
ValidationResult results = await validator.ValidateAsync(saveItemResource);
if (!results.IsValid)
{
return(BadRequest(results.Errors));
}
Item modifiedItem = _mapper.Map <SaveItemResource, Item>(saveItemResource);
await _itemService.UpdateItem(currentItem, modifiedItem);
Item updatedItem = await _itemService.GetItemById(id);
ItemResource updatedItemResource = _mapper.Map <Item, ItemResource>(updatedItem);
return(Ok(updatedItemResource));
}
public async Task <IActionResult> CreateItem([FromBody] SaveItemResource saveItemResource)
{
saveItemResource.SellerId = getUserId();
var validator = new SaveItemResourceValidator();
ValidationResult results = validator.Validate(saveItemResource);
if (!results.IsValid)
{
return(BadRequest(results.Errors));
}
Item itemToCreate = _mapper.Map <SaveItemResource, Item>(saveItemResource);
var newItem = await _itemService.CreateItem(itemToCreate);
if (newItem == null)
{
return(NotFound());
}
var item = await _itemService.GetItemById(newItem.Id);
// map item to itemResource before returning in an OkResult object
ItemResource itemResource = _mapper.Map <Item, ItemResource>(item);
return(Ok(itemResource));
}
public async Task UpdateItem_ReturnNotFoundObject_WhenGetItemByIdReturnsNull()
{
//Arrange
var testItemId = 1;
var itemToBeUpdated = GetTestItems().FirstOrDefault(i => i.Id == testItemId);
var saveItemResource = new SaveItemResource()
{
Title = "Item 1",
Price = 30.00m,
Condition = "New",
IsAuction = false,
SellerId = 1
};
_mockItemService.Setup(service => service.GetItemById(testItemId))
.ReturnsAsync((Item)null);
var controller = new ItemsController(_mockItemService.Object, _mapper);
SetupHttpContextUser(controller, _user);
// Act
var result = await controller.UpdateItem(itemToBeUpdated.Id, saveItemResource);
// Assert
Assert.IsType <NotFoundResult>(result);
}
public async Task UpdateItem_ReturnBadRequestResult_WhenSaveItemResourceIsInvalid()
{
//Arrange
var userId = 1;
var itemId = 1;
var saveItemResource = new SaveItemResource()
{
Title = null,
SellerId = userId
};
var item = new Item()
{
SellerId = userId
};
_mockItemService.Setup(service => service.GetItemById(itemId))
.ReturnsAsync(item);
var controller = new ItemsController(_mockItemService.Object, _mapper);
SetupHttpContextUser(controller, _user);
// Act
var actionResult = await controller.UpdateItem(itemId, saveItemResource);
// Assert
Assert.IsType <BadRequestObjectResult>(actionResult);
}
public async Task UpdateItem_ReturnUnauthorizedResult_WhenUserIsNotTheItemSeller()
{
//Arrange
var itemId = 1;
var saveItemResource = new SaveItemResource()
{
Title = null,
SellerId = 1
};
var item = new Item()
{
SellerId = 1
};
_mockItemService.Setup(service => service.GetItemById(itemId))
.ReturnsAsync(item);
var controller = new ItemsController(_mockItemService.Object, _mapper);
var unauthorizedUser = new ClaimsPrincipal(new ClaimsIdentity(
new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "2")
}
, "TestAuthentication"));
SetupHttpContextUser(controller, unauthorizedUser);
// Act
var actionResult = await controller.UpdateItem(itemId, saveItemResource);
// Assert
Assert.IsType <UnauthorizedResult>(actionResult);
}
public async Task CreateItem_ReturnOkObjectResult_WhenCreateItemIsSuccess()
{
//Arrange
var saveItemResource = new SaveItemResource()
{
Title = "Item 1",
Description = "Description",
Price = 30.00M,
Condition = "New",
Quantity = 1,
IsAuction = false
};
var newItem = _mapper.Map <SaveItemResource, Item>(saveItemResource);
_mockItemService.Setup(service => service.CreateItem(It.IsAny <Item>()))
.ReturnsAsync(newItem);
var controller = new ItemsController(_mockItemService.Object, _mapper);
SetupHttpContextUser(controller, _user);
// Act
var actionResult = await controller.CreateItem(saveItemResource);
// Assert
Assert.IsType <OkObjectResult>(actionResult);
}
public async Task CreateItem_ReturnNotFoundObject_WhenCreateItemMethodReturnsNull()
{
//Arrange
var saveItemResource = new SaveItemResource()
{
Title = "Item 1",
Description = "Description",
Price = 30.00M,
Condition = "New",
IsAuction = false,
SellerId = 1
};
var itemToCreate = _mapper.Map <SaveItemResource, Item>(saveItemResource);
_mockItemService.Setup(service => service.CreateItem(itemToCreate))
.ReturnsAsync((Item)null);
var controller = new ItemsController(_mockItemService.Object, _mapper);
SetupHttpContextUser(controller, _user);
// Act
var actionResult = await controller.CreateItem(saveItemResource);
// Assert
Assert.IsType <NotFoundResult>(actionResult);
}
public IActionResult CreateItem([FromBody] SaveItemResource item)
{
var mappedItem = this.mapper.Map <SaveItemResource, TodoItem>(item);
var domainItem = this.itemRepo.Create(mappedItem);
var result = this.mapper.Map <TodoItem, TodoItemResource>(domainItem);
return(Ok(result));
}
public async Task UpdateItem_ReturnItemResourceInOkObjectResult_WhenUpdateIsSuccess()
{
//Arrange
var itemId = 1;
var saveItemResource = new SaveItemResource()
{
Title = "Updated Item 1",
Price = 30.00M,
Condition = "New",
IsAuction = false,
Quantity = 1,
SellerId = 1
};
var currentItem = GetTestItems().FirstOrDefault(
i => i.Id == itemId);
var expectedItemResource = new ItemResource()
{
Id = itemId,
Title = "Updated Item 1",
Price = 30.00M,
Condition = "New",
IsAuction = false,
Quantity = 1,
SellerId = 1,
ImageUrl = new List <FilePath>()
};
var updatedItem = _mapper.Map <ItemResource, Item>(expectedItemResource);
// subsequent call to GetItemById method to return updatedItem
bool firstCall = true;
_mockItemService.Setup(service => service.GetItemById(itemId))
.ReturnsAsync(() => {
if (firstCall)
{
firstCall = false;
return(currentItem);
}
return(updatedItem);
});
var controller = new ItemsController(_mockItemService.Object, _mapper);
SetupHttpContextUser(controller, _user);
// Act
var result = await controller.UpdateItem(itemId, saveItemResource);
var objectResult = result as OkObjectResult;
var value = objectResult.Value as ItemResource;
// Assert
Assert.IsType <OkObjectResult>(result);
Assert.Equal(serializeObject(expectedItemResource), serializeObject(value));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveItemResource resource)
{
var item = _mapper.Map <SaveItemResource, Item>(resource);
var result = await _itemService.UpdateAsync(id, item);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var itemResource = _mapper.Map <Item, ItemResource>(result.Resource);
return(Ok(itemResource));
}
public async Task CreateItem_ReturnBadRequestResult_WhenSaveItemResourceIsInvalid()
{
//Arrange
var saveItemResource = new SaveItemResource()
{
Title = null
};
var controller = new ItemsController(_mockItemService.Object, _mapper);
SetupHttpContextUser(controller, _user);
// Act
var actionResult = await controller.CreateItem(saveItemResource);
// Assert
Assert.IsType <BadRequestObjectResult>(actionResult);
}
public async Task <IActionResult> CreateItem([FromBody] SaveItemResource saveItemResource)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var item = mapper.Map <SaveItemResource, Item>(saveItemResource);
item.DatePosted = DateTime.Now;
item.LastUpdated = DateTime.Now;
context.Items.Add(item);
await context.SaveChangesAsync();
item = await context.Items.Include(i => i.Category)
.SingleOrDefaultAsync(i => i.Id == item.Id);
var mappedItem = mapper.Map <Item, ItemResource>(item);
return(Ok(mappedItem));
}
public async Task <IActionResult> UpdateItem([FromBody] SaveItemResource saveItemResource, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var itemInDb = await context.Items
.SingleOrDefaultAsync(i => i.Id == id);
if (itemInDb == null)
{
return(NotFound());
}
saveItemResource.DatePosted = itemInDb.DatePosted;
itemInDb.LastUpdated = DateTime.Now;
mapper.Map <SaveItemResource, Item>(saveItemResource, itemInDb);
await context.SaveChangesAsync();
var mappedItem = mapper.Map <Item, ItemResource>(itemInDb);
return(Ok(mappedItem));
}
