Example #1
0
        public async Task PostPais_Created()
        {
            var options = Options;

            var pais = new Pais()
            {
                PaisId = Guid.NewGuid(),
                Nome   = "Brasil",
                Sigla  = "BR",
            };

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var controller = new PaisesController(context);

                var result = await controller.PostPais(pais);

                var createdResult = Assert.IsType <CreatedAtActionResult>(result);
                var paisResult    = Assert.IsType <Pais>(createdResult.Value);
                Assert.Equal(pais, paisResult);
                Assert.Equal("GetPais", createdResult.ActionName);
                Assert.Equal(pais.PaisId, createdResult.RouteValues["id"]);
            }

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var paisResult = await context.Paises.FirstOrDefaultAsync();

                var jsonResult = Newtonsoft.Json.JsonConvert.SerializeObject(paisResult);
                var paisJson   = Newtonsoft.Json.JsonConvert.SerializeObject(pais);

                Assert.Equal(paisJson, jsonResult);
            }
        }
        public async Task PutEstado_NoContet()
        {
            var options = Options;

            var estado = await AdicionarEstado(options);

            using (var context = new CompeticoesDbContext(options))
            {
                estado.Nome = "Santa Catarina";
                var controller = new EstadosController(context);

                var result = await controller.PutEstado(estado.EstadoId, estado);

                var noContentResult = Assert.IsType <NoContentResult>(result);
                Assert.Equal(204, noContentResult.StatusCode);
            }

            using (var context = new CompeticoesDbContext(options))
            {
                var controller = new EstadosController(context);
                var result     = await controller.GetEstado(estado.EstadoId);

                var okResult     = Assert.IsType <OkObjectResult>(result);
                var estadoResult = Assert.IsType <Estado>(okResult.Value);
                Assert.Equal(estado.EstadoId, estadoResult.EstadoId);
                Assert.Equal(estado.Nome, estadoResult.Nome);
            }
        }
        public async Task PostEstado_Created()
        {
            var options = Options;
            var estado  = new Estado()
            {
                EstadoId = Guid.NewGuid(),
                Nome     = "Rio Grande do Sul",
                Sigla    = "RS",
            };

            using (var context = new CompeticoesDbContext(options))
            {
                var controller = new EstadosController(context);

                var result = await controller.PostEstado(estado);

                var createdResult = Assert.IsType <CreatedAtActionResult>(result);
                var estadoResult  = Assert.IsType <Estado>(createdResult.Value);
                Assert.Equal(estado, estadoResult);
                Assert.Equal("GetEstado", createdResult.ActionName);
                Assert.Equal(estado.EstadoId, createdResult.RouteValues["id"]);
            }

            using (var context = new CompeticoesDbContext(options))
            {
                var estadoResult = await context.Estados.FirstOrDefaultAsync();

                var jsonResult = Newtonsoft.Json.JsonConvert.SerializeObject(estadoResult);
                var estadoJson = Newtonsoft.Json.JsonConvert.SerializeObject(estado);

                Assert.Equal(estadoJson, jsonResult);
            }
        }
Example #4
0
        public async Task PutPais_NoContent()
        {
            var options = Options;

            var pais = await AdicionarPais(options);

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                pais.Nome = "Brazil";
                var controller = new PaisesController(context);

                var result = await controller.PutPais(pais.PaisId, pais);

                var noContentResult = Assert.IsType <NoContentResult>(result);
                Assert.Equal(204, noContentResult.StatusCode);
            }

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var controller = new PaisesController(context);
                var result     = await controller.GetPais(pais.PaisId);

                var okResult   = Assert.IsType <OkObjectResult>(result);
                var paisResult = Assert.IsType <Pais>(okResult.Value);
                Assert.Equal(pais.PaisId, paisResult.PaisId);
                Assert.Equal(pais.Nome, paisResult.Nome);
            }
        }
        public async Task GetEstado_NotFound()
        {
            var options = Options;

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var controller = new EstadosController(context);

                var result = await controller.GetEstado(Guid.NewGuid());

                Assert.IsType <NotFoundResult>(result);
            }
        }
        public async Task PutEstado_BadRequest_Id_Diferente()
        {
            var options = Options;

            using (var context = new CompeticoesDbContext(options))
            {
                var controller = new EstadosController(context);

                var result = await controller.PutEstado(Guid.NewGuid(), new Estado());

                var badRequestResult = Assert.IsType <BadRequestResult>(result);
                Assert.Equal(400, badRequestResult.StatusCode);
            }
        }
Example #7
0
        public async Task GetPais_NotFound()
        {
            var options = Options;

            await AdicionarPais(options);

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var controller = new PaisesController(context);

                var result = await controller.GetPais(Guid.NewGuid());

                Assert.IsType <NotFoundResult>(result);
            }
        }
        public async Task GetEstado_Ok()
        {
            var options = Options;

            Estado estado = await AdicionarEstado(options);

            using (var context = new CompeticoesDbContext(options))
            {
                var controller = new EstadosController(context);

                var result = await controller.GetEstado(estado.EstadoId);

                var okResult     = Assert.IsType <OkObjectResult>(result);
                var estadoResult = Assert.IsType <Estado>(okResult.Value);
                Assert.Equal(estado.EstadoId, estadoResult.EstadoId);
            }
        }
Example #9
0
        public async Task GetPais_Ok()
        {
            var options = Options;

            var pais = await AdicionarPais(options);

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var controller = new PaisesController(context);

                var result = await controller.GetPais(pais.PaisId);

                var okResult   = Assert.IsType <OkObjectResult>(result);
                var paisResult = Assert.IsType <Pais>(okResult.Value);
                Assert.Equal(pais.PaisId, paisResult.PaisId);
            }
        }
        public async Task GetEstado_BadRequest()
        {
            var options = Options;

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var controller = new EstadosController(context);

                controller.ModelState.AddModelError("key", "error");

                var result = await controller.GetEstado(Guid.Empty);

                var badRequestResult = Assert.IsType <BadRequestObjectResult>(result);
                var valueResult      = Assert.IsType <SerializableError>(badRequestResult.Value);
                var value            = Assert.IsType <string[]>(valueResult["key"]);
                Assert.Equal("error", value[0]);
            }
        }
        public async Task GetEstados()
        {
            var options = Options;

            var estado = await AdicionarEstado(options);

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                EstadosController controller = new EstadosController(context);

                var result       = controller.GetEstados();
                var estadoResult = result.First();

                Assert.IsAssignableFrom <IEnumerable <Estado> >(result);
                Assert.True(result.Count() == await context.Estados.CountAsync());
                Assert.Equal(estado.EstadoId, estadoResult.EstadoId);
            }
        }
Example #12
0
        public async Task GetPaises()
        {
            var options = Options;

            Pais pais = await AdicionarPais(options);

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                PaisesController controller = new PaisesController(context);

                var result     = controller.GetPaises();
                var paisResult = result.First();

                Assert.IsAssignableFrom <IEnumerable <Pais> >(result);
                Assert.True(result.Count() == await context.Paises.CountAsync());
                Assert.Equal(pais.PaisId, paisResult.PaisId);
            }
        }
Example #13
0
        public async Task PutPais_BadRequest_ModelState_Invalido()
        {
            var options = Options;

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var controller = new PaisesController(context);

                controller.ModelState.AddModelError("Key", "Error");

                var result = await controller.PutPais(Guid.NewGuid(), new Pais());

                var badRequestResult = Assert.IsType <BadRequestObjectResult>(result);
                var valueResult      = Assert.IsType <SerializableError>(badRequestResult.Value);
                var value            = Assert.IsType <string[]>(valueResult["Key"]);
                Assert.Equal("Error", value[0]);
            }
        }
Example #14
0
        private async Task <Pais> AdicionarPais(DbContextOptions <CompeticoesDbContext> options)
        {
            var pais = new Pais()
            {
                PaisId = Guid.NewGuid(),
                Nome   = "Brasil",
                Sigla  = "BR"
            };

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                await context.Paises.AddAsync(pais);

                await context.SaveChangesAsync();
            }

            return(pais);
        }
        private async Task <Estado> AdicionarEstado(
            DbContextOptions <CompeticoesDbContext> options)
        {
            var estado = new Estado()
            {
                EstadoId = Guid.NewGuid(),
                Nome     = "Rio Grande do Sul",
                Sigla    = "RS",
            };

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                await context.Estados.AddAsync(estado);

                await context.SaveChangesAsync();
            }

            return(estado);
        }
Example #16
0
        public async Task DeltePais_Ok()
        {
            var options = Options;

            var pais = await AdicionarPais(options);

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                var controller = new PaisesController(context);

                var result = await controller.DeletePais(pais.PaisId);

                var okResult   = Assert.IsType <OkObjectResult>(result);
                var paisResult = Assert.IsType <Pais>(okResult.Value);
            }

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                Assert.True(!(await context.Paises.AnyAsync(a => a.PaisId == pais.PaisId)));
            }
        }
        public async Task DeleteEstado_Ok()
        {
            var options = Options;

            var estado = await AdicionarEstado(options);

            using (var context = new CompeticoesDbContext(options))
            {
                var controller = new EstadosController(context);

                var result = await controller.DeleteEstado(estado.EstadoId);

                var okResult     = Assert.IsType <OkObjectResult>(result);
                var estadoResult = Assert.IsType <Estado>(okResult.Value);
            }

            using (var context = new CompeticoesDbContext(options))
            {
                Assert.True(!(await context.Estados
                              .AnyAsync(a => a.EstadoId == estado.EstadoId)));
            }
        }
Example #18
0
        public async Task PutPais_ConcurrencyExceptions_NotExists_NotFound()
        {
            var options = Options;

            var pais = await AdicionarPais(options);

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                context.Paises.Remove(pais);
                await context.SaveChangesAsync();
            }

            using (CompeticoesDbContext context = new CompeticoesDbContext(options))
            {
                pais.Nome = "Brazil";
                var controller = new PaisesController(context);

                var result = await controller.PutPais(pais.PaisId, pais);

                Assert.IsType <NotFoundResult>(result);
            }
        }
        public async Task PutEstado_ConcurrencyException_NotExists_NotFound()
        {
            var options = Options;

            var estado = await AdicionarEstado(options);

            using (var context = new CompeticoesDbContext(options))
            {
                context.Estados.Remove(estado);
                await context.SaveChangesAsync();
            }

            using (var context = new CompeticoesDbContext(options))
            {
                estado.Nome = "Santa Catarina";
                var controller = new EstadosController(context);

                var result = await controller.PutEstado(estado.EstadoId, estado);

                Assert.IsType <NotFoundResult>(result);
            }
        }
Example #20
0
 public EstadosController(CompeticoesDbContext context)
 {
     _context = context;
 }
Example #21
0
 public PaisesController(CompeticoesDbContext context)
 {
     _context = context;
 }
Example #22
0
 public CidadesController(CompeticoesDbContext context)
 {
     _context = context;
 }