public async Task Post_CardType_The_Guid_is_empty()
        {
            CardType cardType = new CardType
            {
                Id   = Guid.Empty,
                Name = "1"
            };

            var service = new CardTypeService(_httpClient);
            var result  = await service.PostCardType(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)
                                  );
            }
        }
        public async Task Put_CardType_Valido()
        {
            Guid guid = new Guid("5E210F4F-D12B-4F85-8464-6F8740920FAA");

            CardType cardType = new CardType
            {
                Id   = guid,
                Name = "ALTERADO..."
            };

            var service = new CardTypeService(_httpClient);
            var result  = await service.PutCardType(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 name has already been taken.", item)
                                  );
            }
        }
        public async Task Delete_ByIdCardType_Valido()
        {
            Guid id = new Guid("5E210F4F-D12B-4F85-8464-6F8740920FAA");

            var service = new CardTypeService(_httpClient);
            var result  = await service.DeleteByIdCardType(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)
                                  );
            }
        }
        public async Task Put_CardType_The_Name_must_have_between_2_and_30_characters()
        {
            Guid guid = new Guid("1BF784F8-7B94-47EC-9FD9-5257D83E8E7D");

            CardType cardType = new CardType
            {
                Id   = guid,
                Name = "o"
            };

            var service = new CardTypeService(_httpClient);
            var result  = await service.PutCardType(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 name has already been taken.", item)
                                  );
            }
        }
Example #5
0
        public static async Task <dynamic> GetCardTypeByName(string name)
        {
            var serviceTipoCartao = new CardTypeService(_httpClient);
            var resultTipoCartao  = await serviceTipoCartao.GetByNameCardType(requestUri, name);

            return(resultTipoCartao);
        }
        public async Task Get_AllCardType()
        {
            var service = new CardTypeService(_httpClient);
            var result  = await service.GetAllCardTypes(requestUri);

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

            var service = new CardTypeService(_httpClient);
            var result  = await service.GetHistorycByIdCardType(requestUri, info);

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

            var service = new CardTypeService(_httpClient);
            var result  = await service.GetByNameCardType(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()
        {
            List <string> tipoCartao = new List <string>();

            var serviceTipoCartao = new CardTypeService(_httpClient);
            var resultTipoCartao  = await serviceTipoCartao.GetAllCardTypes(requestUri);

            foreach (var item in resultTipoCartao.Data)
            {
                tipoCartao.Add(item.Name);
            }

            return(tipoCartao);
        }
Example #10
0
        public static async Task <dynamic> Information()
        {
            var serviceTipoCartao = new CardTypeService(_httpClient);
            var resultTipoCartao  = await serviceTipoCartao.GetAllCardTypes(requestUri);

            foreach (var item in resultTipoCartao.Data)
            {
                cardType.Add(new CardType {
                    Id = item.Id, Name = item.Name
                });
            }

            return(cardType);
        }