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();
        }
Esempio n. 2
0
        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);
        }
Esempio n. 4
0
        public async Task Get_Categoria()
        {
            var service = new CategoriasController(_mockContext.Object);
            await service.GetCategoria(1);

            _mockSet.Verify(m => m.FindAsync(1), Times.Once());
        }
Esempio n. 5
0
        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());
        }
Esempio n. 6
0
        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);
        }
Esempio n. 7
0
        protected void Page_Load(object sender, EventArgs e)
        {
            CategoriasController ctrl = new CategoriasController();

            gvCategorias.DataSource = ctrl.Listar();
            gvCategorias.DataBind();
        }
Esempio n. 8
0
        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);
        }
Esempio n. 9
0
        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);
        }
Esempio n. 10
0
        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);
        }
Esempio n. 13
0
        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));
        }
Esempio n. 14
0
        public void GetCategorias_Return_BadRequestResult()
        {
            var controller = new CategoriasController(repository, mapper);

            var data = controller.Get();

            Assert.IsType <BadRequestResult>(data.Result);
        }
Esempio n. 15
0
 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);
        }
Esempio n. 17
0
        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());
        }
Esempio n. 20
0
        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());
        }
Esempio n. 23
0
        [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
        }
Esempio n. 24
0
        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());
        }
Esempio n. 25
0
        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);
        }
Esempio n. 26
0
        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);
        }
Esempio n. 28
0
        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());
        }
Esempio n. 30
0
        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
        }