public async Task UpdateQuantidade_Invalid_ProdutoId()
{
//arrange
var clienteId = "cliente_id";
UpdateQuantidadeInput updateQuantidadeInput = new UpdateQuantidadeInput(null, 7);
carrinhoServiceMock
.Setup(c => c.UpdateItem(clienteId, It.IsAny <UpdateQuantidadeInput>()))
.ReturnsAsync(new UpdateQuantidadeOutput(new ItemCarrinho(), new CarrinhoCliente()))
.Verifiable();
var controller = GetCarrinhoController();
SetControllerUser(clienteId, controller);
controller.ModelState.AddModelError("ProdutoId", "Required");
//act
var result = await controller.UpdateQuantidade(updateQuantidadeInput);
//assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.IsType <SerializableError>(badRequestObjectResult.Value);
catalogoServiceMock.Verify();
}
public async Task UpdateCarrinhoAsync_success()
{
//arrange
var json1 = JsonConvert.SerializeObject(new CarrinhoCliente("123")
{
Itens = new List <ItemCarrinho> {
new ItemCarrinho("001", "001", "produto 001", 12.34m, 1)
}
});
var json2 = JsonConvert.SerializeObject(new CarrinhoCliente("123")
{
Itens = new List <ItemCarrinho> {
new ItemCarrinho("001", "001", "produto 001", 12.34m, 2)
}
});
string clienteId = "123";
var databaseMock = new Mock <IDatabase>();
databaseMock
.Setup(d => d.StringSetAsync(
It.IsAny <RedisKey>(),
It.IsAny <RedisValue>(),
null,
When.Always,
CommandFlags.None
))
.ReturnsAsync(true)
.Verifiable();
databaseMock
.SetupSequence(d => d.StringGetAsync(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>()))
.ReturnsAsync("")
.ReturnsAsync(json1)
.ReturnsAsync(json2);
redisMock
.Setup(r => r.GetDatabase(It.IsAny <int>(), It.IsAny <object>()))
.Returns(databaseMock.Object)
.Verifiable();
var repository
= new RedisCarrinhoRepository(loggerMock.Object, redisMock.Object);
var item = new UpdateQuantidadeInput("001", 2);
//act
var output = await repository.UpdateCarrinhoAsync(clienteId, item);
//assert
Assert.Equal(clienteId, output.CarrinhoCliente.ClienteId);
Assert.Collection(output.CarrinhoCliente.Itens,
i =>
{
Assert.Equal("001", i.ProdutoId);
Assert.Equal(2, i.Quantidade);
});
databaseMock.Verify();
redisMock.Verify();
}
public async Task <IActionResult> Post([FromBody] UpdateQuantidadeInput input)
{
if (input.ItemPedidoId <= 0)
{
return(BadRequest($"Id o item de pedido inválido: {input.ItemPedidoId}"));
}
return(Ok(await pedidoRepository.UpdateQuantidade(input)));
}
public async Task <IActionResult> UpdateQuantidade([FromBody] UpdateQuantidadeInput input)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UpdateQuantidadeOutput value = await carrinhoService.UpdateItem(GetUserId(), input);
if (value == null)
{
return(NotFound(input));
}
return(base.Ok(value));
}
public async Task UpdateQuantidade_ProdutoId_NotFound()
{
//arrange
var clienteId = "cliente_id";
UpdateQuantidadeInput updateQuantidadeInput = new UpdateQuantidadeInput("001", 7);
carrinhoServiceMock
.Setup(c => c.UpdateItem(clienteId, It.IsAny <UpdateQuantidadeInput>()))
.ReturnsAsync((UpdateQuantidadeOutput)null)
.Verifiable();
var controller = GetCarrinhoController();
SetControllerUser(clienteId, controller);
//act
var result = await controller.UpdateQuantidade(updateQuantidadeInput);
//assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.Equal(updateQuantidadeInput, notFoundObjectResult.Value);
catalogoServiceMock.Verify();
}
public async Task UpdateQuantidade_Success()
{
//arrange
var clienteId = "cliente_id";
var controller = GetCarrinhoController();
SetControllerUser(clienteId, controller);
var itemCarrinho = GetFakeItemCarrinho();
UpdateQuantidadeInput updateQuantidadeInput = new UpdateQuantidadeInput("001", 7);
carrinhoServiceMock
.Setup(c => c.UpdateItem(clienteId, It.IsAny <UpdateQuantidadeInput>()))
.ReturnsAsync(new UpdateQuantidadeOutput(itemCarrinho, new CarrinhoCliente()))
.Verifiable();
//act
var result = await controller.UpdateQuantidade(updateQuantidadeInput);
//assert
var okObjectResult = Assert.IsType <OkObjectResult>(result);
Assert.IsType <UpdateQuantidadeOutput>(okObjectResult.Value);
catalogoServiceMock.Verify();
}
public async Task <UpdateQuantidadeOutput> UpdateQuantidade(UpdateQuantidadeInput input)
{
var itemPedidoDB = await itemPedidoRepository.GetItemPedido(input.ItemPedidoId);
if (itemPedidoDB != null)
{
itemPedidoDB.AtualizaQuantidade(input.Quantidade);
if (input.Quantidade == 0)
{
await itemPedidoRepository.RemoveItemPedido(input.ItemPedidoId);
}
await contexto.SaveChangesAsync();
var pedido = await GetPedido();
var carrinhoViewModel = new CarrinhoViewModel(pedido.Id, pedido.Itens);
return(new UpdateQuantidadeOutput(itemPedidoDB, carrinhoViewModel));
}
throw new ArgumentException("ItemPedido não encontrado");
}
public async Task <UpdateQuantidadeOutput> UpdateItemCarrinhoAsync(string customerId, UpdateQuantidadeInput item)
{
if (item == null)
{
throw new ArgumentNullException();
}
if (string.IsNullOrWhiteSpace(item.Id))
{
throw new ArgumentException();
}
if (item.Quantity < 0)
{
throw new ArgumentOutOfRangeException();
}
var basket = await GetCarrinhoAsync(customerId);
ItemCarrinho itemDB = basket.Itens.Where(i => i.ProdutoId == item.Id).SingleOrDefault();
itemDB.Quantidade = item.Quantity;
if (item.Quantity == 0)
{
basket.Itens.Remove(itemDB);
}
CarrinhoCliente customerBasket = await UpdateCarrinhoAsync(basket);
return(new UpdateQuantidadeOutput(itemDB, customerBasket));
}
public async Task <ActionResult <UpdateQuantidadeOutput> > UpdateItem(string clienteId, [FromBody] UpdateQuantidadeInput input)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var carrinho = await _repository.UpdateCarrinhoAsync(clienteId, input);
return(Ok(carrinho));
}
catch (KeyNotFoundException)
{
return(NotFound(clienteId));
}
}
public async Task <UpdateQuantidadeOutput> UpdateItem(string clienteId, UpdateQuantidadeInput input)
{
var uri = $"{CarrinhoUris.UpdateItem}/{clienteId}";
return(await PutAsync <UpdateQuantidadeOutput>(uri, input));
}
public async Task <ActionResult <UpdateQuantidadeResponse> > UpdateQuantidade([FromBody] UpdateQuantidadeInput input)
{
//return await carrinhoRepository.UpdateQuantidadeAsync(itemPedido);
string clienteId = userManager.GetUserId(this.User);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var output = await carrinhoRepository.UpdateItemCarrinhoAsync(clienteId, input);
return(Ok(output));
}
catch (KeyNotFoundException)
{
return(NotFound(clienteId));
}
}
public async Task <ActionResult <UpdateQuantidadeOutput> > UpdateItem(string clienteId, [FromBody] UpdateQuantidadeInput input)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var output = await _repository.UpdateCarrinhoAsync(clienteId, input);
await this._connection
.InvokeAsync("UpdateUserBasketCount", $"{clienteId}", output.CarrinhoCliente.Itens.Count);
return(Ok(output));
}
catch (KeyNotFoundException)
{
return(NotFound(clienteId));
}
}