public async Task Delete_ByIdCardBrand_Valido()
        {
            Guid id = new Guid("5e210f4f-d12b-4f85-8464-6f8740920faa");

            var service = new CardBrandService(_httpClient);
            var result  = await service.DeleteByIdCardBrand(requestUri, id);

            // Assert
            if (result.Status == HttpStatusCode.OK)
            {
                Assert.True(result.Status == HttpStatusCode.OK, "OK");
            }
            else
            {
                List <string> listError = new List <string>();
                foreach (string error in result.Data)
                {
                    listError.Add(error);
                }
                Assert.Collection(listError,
                                  item => Assert.Equal("The Guid is empty", item),
                                  item => Assert.Equal("The Guid is invalid and contains 00000000", item),
                                  item => Assert.Equal("Registro não encontrado", item)
                                  );
            }
        }
Example #2
0
        public static async Task <dynamic> GetCardBrandByName(string name)
        {
            var serviceBandeiraCartao = new CardBrandService(_httpClient);
            var resultBandeiraCartao  = await serviceBandeiraCartao.GetByNameCardBrand(requestUri, name);

            return(resultBandeiraCartao);
        }
        public async Task Post_CardBrand_The_Guid_is_empty()
        {
            CardBrand cardBrand = new CardBrand
            {
                Id   = Guid.Empty,
                Name = "1"
            };

            var service = new CardBrandService(_httpClient);
            var result  = await service.PostCardBrand(requestUri, cardBrand);

            if (result.Status == HttpStatusCode.OK)
            {
                Assert.True(result.Status == HttpStatusCode.OK, "OK");
            }
            else
            {
                List <string> listError = new List <string>();
                foreach (string error in result.Data)
                {
                    listError.Add(error);
                }
                Assert.Collection(listError,
                                  item => Assert.Equal("The Name is Required", item),
                                  item => Assert.Equal("The Name must have between 2 and 30 characters", item),
                                  item => Assert.Equal("The Guid is empty", item),
                                  item => Assert.Equal("The Guid is invalid and contains 00000000", item),
                                  item => Assert.Equal("The card brand id has already been taken.", item),
                                  item => Assert.Equal("The card brand name has already been taken.", item)
                                  );
            }
        }
        public async Task Put_CardBrand_Valido()
        {
            Guid guid = new Guid("5E210F4F-D12B-4F85-8464-6F8740920FAA");

            CardBrand cardBrand = new CardBrand
            {
                Id   = guid,
                Name = "ALTERADO..."
            };

            var service = new CardBrandService(_httpClient);
            var result  = await service.PutCardBrand(requestUri, cardBrand);

            if (result.Status == HttpStatusCode.OK)
            {
                Assert.True(result.Status == HttpStatusCode.OK, "OK");
            }
            else
            {
                List <string> listError = new List <string>();
                foreach (string error in result.Data)
                {
                    listError.Add(error);
                }
                Assert.Collection(listError,
                                  item => Assert.Equal("The Name is Required", item),
                                  item => Assert.Equal("The Name must have between 2 and 30 characters", item),
                                  item => Assert.Equal("The Guid is empty", item),
                                  item => Assert.Equal("The Guid is invalid and contains 00000000", item),
                                  item => Assert.Equal("The card brand name has already been taken.", item)
                                  );
            }
        }
        public async Task Put_CardBrand_The_Name_must_have_between_2_and_30_characters()
        {
            Guid guid = new Guid("1BF784F8-7B94-47EC-9FD9-5257D83E8E7D");

            CardBrand cardBrand = new CardBrand
            {
                Id   = guid,
                Name = "o"
            };

            var service = new CardBrandService(_httpClient);
            var result  = await service.PutCardBrand(requestUri, cardBrand);

            if (result.Status == HttpStatusCode.OK)
            {
                Assert.True(result.Status == HttpStatusCode.OK, "OK");
            }
            else
            {
                List <string> listError = new List <string>();
                foreach (string error in result.Data)
                {
                    listError.Add(error);
                }
                Assert.Collection(listError,
                                  item => Assert.Equal("The Name is Required", item),
                                  item => Assert.Equal("The Name must have between 2 and 30 characters", item),
                                  item => Assert.Equal("The Guid is empty", item),
                                  item => Assert.Equal("The Guid is invalid and contains 00000000", item),
                                  item => Assert.Equal("The card brand name has already been taken.", item)
                                  );
            }
        }
        public async Task Get_AllCardBrand()
        {
            var service = new CardBrandService(_httpClient);
            var result  = await service.GetAllCardBrands(requestUri);

            // Assert
            Assert.False(result.Status == HttpStatusCode.BadRequest, "ERROR");
            Assert.True(result.Status == HttpStatusCode.OK, "OK");
        }
        public async Task Get_HistorycByIdCardBrand()
        {
            string info = "5E210F4F-D12B-4F85-8464-6F8740920FAA";

            var service = new CardBrandService(_httpClient);
            var result  = await service.GetHistorycByIdCardBrand(requestUri, info);

            // Assert
            Assert.False(result.Status == HttpStatusCode.BadRequest, "ERROR");
            Assert.True(result.Status == HttpStatusCode.OK, "OK");
        }
        public async Task Get_ByNameCardBrand()
        {
            string info = "ALTERADO...";

            var service = new CardBrandService(_httpClient);
            var result  = await service.GetByNameCardBrand(requestUri, info);

            // Assert
            Assert.False(result.Status == HttpStatusCode.BadRequest, "ERROR");
            Assert.True(result.Status == HttpStatusCode.OK, "OK");
        }
Example #9
0
        public static async Task <dynamic> InformationCombo()
        {
            var serviceBandeiraCartao = new CardBrandService(_httpClient);
            var resultBandeiraCartao  = await serviceBandeiraCartao.GetAllCardBrands(requestUri);

            List <string> cardBrand = new List <string>();

            foreach (var item in resultBandeiraCartao.Data)
            {
                cardBrand.Add(item.Name);
            }

            return(cardBrand);
        }
        public async Task Post_CardBrand_Seed()
        {
            List <CardBrand> listCardBrand = new List <CardBrand>();

            listCardBrand.Add(new CardBrand
            {
                Id   = Guid.NewGuid(),
                Name = "Visa"
            });

            listCardBrand.Add(new CardBrand
            {
                Id   = Guid.NewGuid(),
                Name = "Master"
            });

            listCardBrand.Add(new CardBrand
            {
                Id   = Guid.NewGuid(),
                Name = "Amex"
            });

            foreach (CardBrand cardType in listCardBrand)
            {
                var service = new CardBrandService(_httpClient);
                var result  = await service.PostCardBrand(requestUri, cardType);

                if (result.Status == HttpStatusCode.OK)
                {
                    Assert.True(result.Status == HttpStatusCode.OK, "OK");
                }
                else
                {
                    List <string> listError = new List <string>();
                    foreach (string error in result.Data)
                    {
                        listError.Add(error);
                    }
                    Assert.Collection(listError,
                                      item => Assert.Equal("The Name is Required", item),
                                      item => Assert.Equal("The Name must have between 2 and 30 characters", item),
                                      item => Assert.Equal("The Guid is empty", item),
                                      item => Assert.Equal("The Guid is invalid and contains 00000000", item),
                                      item => Assert.Equal("The card type id has already been taken.", item),
                                      item => Assert.Equal("The card type name has already been taken.", item)
                                      );
                }
            }
        }