public void DeleteCategoriaOk()
{
var logicMock = new Mock <ICategoria>(MockBehavior.Strict);
CategoriasController controller = new CategoriasController(logicMock.Object);
CategoriaModel catModel = new CategoriaModel()
{
Nombre = "Playa",
};
Categoria cat = new Categoria()
{
Nombre = catModel.Nombre,
Id = 0,
};
logicMock.Setup(x => x.Categoria(catModel.Nombre)).Returns(cat);
logicMock.Setup(x => x.AgregarCategoria(cat));
controller.Post(1, catModel);
logicMock.Setup(x => x.BorrarCategoriaId(1));
var result = controller.Delete(1);
var okResult = result as OkObjectResult;
logicMock.VerifyAll();
}
public async Task AddaCategory()
{
//Arrange
var BDName = Guid.NewGuid().ToString();
var context = BuildContext(BDName);
//Act
var newcategory = new CreateCategoriaViewModel()
{
Nombre = "A1",
Descripcion = "Un tipo de vehiculo",
};
var controller = new CategoriasController(context);
var response = await controller.Create(newcategory);
//Assert
Assert.IsNotNull(response);
}
public void GetCategoriasConElementoOk()
{
var logicMock = new Mock <ICategoria>(MockBehavior.Strict);
CategoriasController controller = new CategoriasController(logicMock.Object);
CategoriaModel catModel = new CategoriaModel()
{
Nombre = "Playa",
};
Categoria cat = new Categoria()
{
Nombre = catModel.Nombre,
Id = 0,
};
logicMock.Setup(x => x.Categoria(catModel.Nombre)).Returns(cat);
logicMock.Setup(x => x.AgregarCategoria(cat));
List <Categoria> lista = new List <Categoria>();
lista.Add(cat);
logicMock.Setup(x => x.ObtenerTodas()).Returns(lista);
controller.Post(1, catModel);
var result = controller.Get();
var okResult = result as OkObjectResult;
var retorno = okResult.Value as List <Categoria>;
logicMock.VerifyAll();
Assert.AreEqual(1, retorno.Count);
}
public async Task Get_Categoria()
{
var service = new CategoriasController(_mockContext.Object);
await service.GetCategoria(1);
_mockSet.Verify(m => m.FindAsync(1), Times.Once());
}
public async Task Put_Categoria()
{
var service = new CategoriasController(_mockContext.Object);
await service.PutCategoria(1, _categoria);
_mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once());
}
public async void Post_Categoria_AddValidData_Return_CreatedResult()
{
//Arrange
var controller = new CategoriasController(_repositoryMock.Object, _mapperMock.Object);
var cat = new Categoria()
{
Nome = "Teste2", ImagemUrl = "http://www.delsivan.net/Imagens/2.jpg"
};
var catDTO = new CategoriaDTO()
{
Nome = "Teste2", ImagemUrl = "http://www.delsivan.net/Imagens/2.jpg"
};
_repositoryMock.Setup(x => x.CategoriaRepository.Add(cat));
_repositoryMock.Setup(x => x.Commit());
_mapperMock.Setup(x => x.Map <Categoria>(catDTO))
.Returns(cat);
//Act
var data = await controller.Post(catDTO);
//Assert
Assert.IsType <CreatedAtRouteResult>(data);
_repositoryMock.Verify(x => x.CategoriaRepository.Add(cat), Times.Once);
_repositoryMock.Verify(x => x.Commit(), Times.Once);
}
protected void Page_Load(object sender, EventArgs e)
{
CategoriasController ctrl = new CategoriasController();
gvCategorias.DataSource = ctrl.Listar();
gvCategorias.DataBind();
}
public async void GetCategoriaById_Return_OkResult()
{
//Arrange
var controller = new CategoriasController(_repositoryMock.Object, _mapperMock.Object);
var catId = 10;
var categoriaEsperada = new Categoria {
CategoriaId = 10, Nome = "Teste"
};
var categoriaEsperadaDTO = new CategoriaDTO {
CategoriaId = 10, Nome = "Teste"
};
_repositoryMock.Setup(x => x.CategoriaRepository.GetById(c => c.CategoriaId == catId)).ReturnsAsync(categoriaEsperada);
_mapperMock.Setup(x => x.Map <CategoriaDTO>(categoriaEsperada))
.Returns(categoriaEsperadaDTO);
//Act
var data = await controller.Get(catId);
//Assert
Assert.IsType <CategoriaDTO>(data.Value);
Assert.Equal(catId, data.Value.CategoriaId);
Assert.Equal("Teste", data.Value.Nome);
}
public async void Put_Categoria_Update_BadRequest()
{
//Arrange
var controller = new CategoriasController(_repositoryMock.Object, _mapperMock.Object);
var catId = 18;
var cat = new Categoria()
{
CategoriaId = 20, Nome = "Teste3", ImagemUrl = "http://www.delsivan.net/Imagens/2.jpg"
};
var catDTO = new CategoriaDTO()
{
CategoriaId = 20, Nome = "Teste3", ImagemUrl = "http://www.delsivan.net/Imagens/3.jpg"
};
_repositoryMock.Setup(x => x.CategoriaRepository.Update(cat));
_repositoryMock.Setup(x => x.Commit());
//Act
var data = await controller.Put(catId, catDTO);
//Assert
var returnObject = Assert.IsType <BadRequestObjectResult>(data);
Assert.Equal(400, returnObject.StatusCode);
Assert.Equal($"Não foi possível atualizar a categoria com id={catId}", returnObject.Value);
}
public async void Put_Categoria_Update_ValidData_Return_OkResult()
{
//Arrange
var controller = new CategoriasController(_repositoryMock.Object, _mapperMock.Object);
var catId = 18;
var cat = new Categoria()
{
CategoriaId = catId, Nome = "Teste3", ImagemUrl = "http://www.delsivan.net/Imagens/2.jpg"
};
var catDTO = new CategoriaDTO()
{
CategoriaId = catId, Nome = "Teste3", ImagemUrl = "http://www.delsivan.net/Imagens/3.jpg"
};
_repositoryMock.Setup(x => x.CategoriaRepository.Update(cat));
_repositoryMock.Setup(x => x.Commit());
_mapperMock.Setup(x => x.Map <Categoria>(catDTO))
.Returns(cat);
//Act
var data = await controller.Put(catId, catDTO);
//Assert
Assert.IsType <OkObjectResult>(data);
}
public void GetCategoriaIdOk()
{
var logicMock = new Mock <ICategoria>(MockBehavior.Strict);
CategoriasController controller = new CategoriasController(logicMock.Object);
CategoriaModel catModel = new CategoriaModel()
{
Nombre = "Playa",
};
Categoria cat = new Categoria()
{
Nombre = catModel.Nombre,
Id = 0,
};
logicMock.Setup(x => x.Categoria(catModel.Nombre)).Returns(cat);
logicMock.Setup(x => x.AgregarCategoria(cat));
logicMock.Setup(x => x.ObtenerCategoriaId(1)).Returns(cat);
controller.Post(1, catModel);
var result = controller.Get(1);
var okResult = result as OkObjectResult;
var retorno = okResult.Value as Categoria;
logicMock.VerifyAll();
Assert.AreEqual(catModel.Nombre, retorno.Nombre);
}
public void PutCategoriaOk()
{
var logicMock = new Mock <ICategoria>(MockBehavior.Strict);
CategoriasController controller = new CategoriasController(logicMock.Object);
CategoriaModel catModel = new CategoriaModel()
{
Nombre = "Playa",
};
Categoria cat = new Categoria()
{
Nombre = catModel.Nombre,
Id = 0,
};
logicMock.Setup(x => x.Categoria(catModel.Nombre)).Returns(cat);
logicMock.Setup(x => x.AgregarCategoria(cat));
controller.Post(0, catModel);
cat.Nombre = "prueba";
logicMock.Setup(x => x.ActualizarCategoria(cat.Id, cat));
var result = controller.Put(cat.Id, cat);
var okResult = result as OkObjectResult;
logicMock.VerifyAll();
Assert.AreEqual("prueba", cat.Nombre);
}
public void Delete()
{
CategoriasController controller = new CategoriasController(container);
System.Web.Http.Results.OkNegotiatedContentResult <Categoria> result = (System.Web.Http.Results.OkNegotiatedContentResult <Categoria>)controller.DeleteCategoria(3);
Assert.IsNull(container.GetCategoria(3));
}
public void GetCategorias_Return_BadRequestResult()
{
var controller = new CategoriasController(repository, mapper);
var data = controller.Get();
Assert.IsType <BadRequestResult>(data.Result);
}
public frmConfigGrupo()
{
InitializeComponent();
gruposController = new GruposController();
categoriasController = new CategoriasController();
parametrosController = new ParametrosController();
parametrosModel = new ParametrosModel();
}
private CategoriasController GetController()
{
var controller = new CategoriasController();
controller.ControllerContext = new ControllerContext(HttpContextBaseMock.Object, new RouteData(), controller);
controller.Url = new UrlHelper(new RequestContext(HttpContextBaseMock.Object, new RouteData()), Routes);
return(controller);
}
public void GetCategorias_Return_OkResult()
{
var controller = new CategoriasController(repository, mapper);
var data = controller.Get();
Assert.IsType <List <CategoriaDTO> >(data.Value);
}
public async System.Threading.Tasks.Task Get_categorias()
{
var service = new CategoriasController(_mockContexto.Object);
await service.Categoriasid(1);
_mockSet.Verify(m => m.FindAsync(1),
Times.Once());
}
public async Task Post_Categoria()
{
var service = new CategoriasController(_mockContext.Object);
await service.PostCategoria(_categoria);
_mockSet.Verify(x => x.Add(_categoria), Times.Once);
_mockContext.Verify(expression: m => m.SaveChangesAsync(It.IsAny <CancellationToken>()),
Times.Once());
}
public async Task GetCategoria()
{
var service = new CategoriasController(mockContext.Object);
var testCategoria = await service.GetCategoria(id : 1);
mockSet.Verify(expression: m => m.FindAsync(params keyValues: 1),
Times.Once());
Assert.Equal(expected: categoria, actual: testCategoria);
}
public async Task Put_Categoria()
{
var service = new CategoriasController(_mockContext.Object);
await service.PutCategoria(1, _categoria);
_mockSet.Verify(m => m.SaveChangesAsync,
Times.Once());
}
public async Task Delete_Categoria()
{
var service = new CategoriasController(_mockContext.Object);
await service.DeleteCategoria(1);
_mockSet.Verify(m => m.FindAsync(1), Times.Once());
_mockSet.Verify(x => x.Remove(_categoria), Times.Once);
_mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once());
}
[Fact] //Xunit
public async Task Get_Categoria()
{
var service = new CategoriasController(_mockContext.Object); //Feito isso eu vou ter todos os metodos da minha API Controller categorias
//Verifiamos se o findAsync foi executado uma vez só
await service.GetCategoria(id : 1); //Dentro do parametro utilizar a controller da API, vou dar um get passando o ID =1
_mockSet.Verify(expression: m => m.FindAsync(1), Times.Once()); //Vou verificar se ele executou meu FindAsync
}
public async Task Get_Categoria()
{
var service = new CategoriasController(_mockContext.Object);
await service.GetCategoria(id : 1);
_mockSet.Verify(expression: m => m.FindAsync(params keyValues: 1),
Times.Once());
}
protected void btnSalvar_Click(object sender, EventArgs e)
{
CategoriasController ctrl = new CategoriasController();
Categoria categoria = new Categoria();
categoria.Nome = txtNome.Text;
categoria.Descricao = txtDesc.Text;
ctrl.Adicionar(categoria);
}
protected void btnSalvar_Click(object sender, EventArgs e)
{
Categoria cat = new Categoria();
cat.Nome = txtNome.Text;
cat.Descricao = txtDescricao.Text;
cat.Ativo = true;
CategoriasController.Adicionar(cat);
}
public async Task Get_Categoria()
{
var service = new CategoriasController(_mockContext.Object); //pass the context mock to get all methods disponible in CategoriasController
await service.GetCategoria(1); //do a get categoria passig id 1
_mockSet.Verify(m => m.FindAsync(1), //uses mockset to verify if findasync was executed one time
Times.Once);
}
public void GetBySlug()
{
CategoriasController controller = new CategoriasController(container);
System.Web.Http.Results.OkNegotiatedContentResult <Categoria> result = (System.Web.Http.Results.OkNegotiatedContentResult <Categoria>)controller.GetCategoria("computador", "laptop");
Assert.IsNotNull(result);
Assert.AreEqual("laptop", result.Content.Slug);
}
public async Task Put_Categoria()
{
var service = new CategoriasController(_mockContext.Object);
await service.PutCategoria(1, _categoria);
// Verifica se o método foi realmente chamado e se foi executado somente uma vez
_mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once());
}
public async Task Put_Categoria()
{
//Esses teste são para ver se eles foram executados um de cada vez cada 1
var service = new CategoriasController(_mockContext.Object);
await service.PutCategoria(1, _categoria);
_mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once);// Vai testar se vai executar o saveChanges
}
