Testes em .NET: fundamentos, boas práticas e automação em pipelines CI/CD

Testes de software: o que, por que e quando testar - Apresentação

Apresentando o curso e os instrutores

Olá! Seja bem-vindo ao curso de Teste de Software com o .NET. Eu sou o Vinicius Costa Santos e acompanharei você nessa jornada.

Introduzindo a importância dos testes de software

Ao longo das próximas aulas, nós vamos aprender como escrever códigos mais seguros, confiáveis e mais fáceis de manter. Este curso é voltado para quem já domina o C# e o ambiente do .NET, além de quem já trabalha e sabe desenvolver aplicações web e APIs.

Considerando esses pré-requisitos, é provável que já tenhamos passado por situações em que tudo parece bem escrito e funcionando corretamente. Funciona em nossa máquina, mas, ao colocar em produção, ocorre um desastre: tudo quebra e nada mais funciona. Precisamos entender o que aconteceu e o que deu errado.

Explorando a função dos testes no desenvolvimento

É nesse contexto que introduzimos a ideia de teste de software. O teste de software serve para antecipar problemas e garantir que nosso software não vá para a produção com falhas. Os testes de software não são apenas uma etapa do desenvolvimento, mas uma forma de pensar, uma maneira de garantir que o código faz o que precisa fazer.

Ter confiança para evoluir nosso sistema sem o risco de comprometer o que já está funcionando é fundamental. No ambiente do .NET, utilizando as ferramentas corretas, podemos executar esses testes de forma automatizada, sem a necessidade de realizá-los manualmente, um a um.

Detalhando o conteúdo do curso

Neste curso, abordaremos os fundamentos de defeitos, erros e falhas, compreendendo a diferença entre cada um deles. Também exploraremos os tipos de testes existentes e suas abordagens. Em seguida, começaremos a prática, realizando testes em APIs com ferramentas do C#, como o xUnit e o FluentAssertions, além de aplicar boas práticas para validar nossas respostas e parametrizar pipelines de CI/CD. Isso garantirá que os testes sejam sempre executados automaticamente, protegendo nosso sistema de possíveis defeitos que possam ser introduzidos em produção.

Discutindo boas práticas e cultura de qualidade

Por fim, discutiremos boas práticas de manutenção e escalabilidade dos testes, visando manter nosso sistema saudável ao longo do tempo e durante sua evolução. O objetivo é não apenas ensinar a escrever e criar testes, mas também fomentar uma cultura de qualidade sólida em nossa forma de trabalhar.

Preparemos nosso Visual Studio e exploremos como os testes podem transformar a maneira como desenvolvemos softwares.

Testes de software: o que, por que e quando testar - O que é teste de software?

Introduzindo o conceito de teste de software

Olá, Dev! Agora que já entendemos por que testar um software, vamos entrar no fundamento do que é um teste de software. Muitas pessoas confundem o teste de software apenas com a execução do software para verificar se ele está rodando ou não. Ou seja, se o software foi colocado para executar e abriu, ele está funcionando; se não abriu, não está funcionando. No entanto, um teste de software é mais do que isso. Um teste de software é um processo de verificação para assegurar que o software está fazendo o que foi projetado para fazer e se está fazendo isso da maneira correta.

O objetivo não é verificar se o código está perfeito ou se é o melhor código do mundo, mas sim se o software está operando como esperado e cumprindo suas funções. O teste é uma atividade de investigação, na qual verificamos se todos os requisitos definidos estão sendo atendidos e se o software está se comportando conforme o esperado.

Exemplificando testes com código

Podemos ver um exemplo no Visual Studio, com uma calculadora. Temos uma classe Calculadora com um método Soma, que é estático e recebe dois valores, a e b, retornando a soma desses valores. Isso é simples de fazer. Vamos ver como isso é implementado no código:

class Calculadora
{
    public static double Soma(double a, double b)
    {
        return a + b;
    }
}

Para testar, podemos executar o programa: se o primeiro valor for 10 e o segundo 5, o resultado será 15. Se tentarmos outro valor, como 50 menos 20, o resultado será 30. Podemos repetir isso várias vezes, mas em sistemas mais complexos, essa tarefa não é interessante de ser feita manualmente.

Automatizando testes e prevenindo erros

Podemos escrever um trecho de código que realiza esse tipo de teste automaticamente. No caso da soma, isso parece bom, mas também garante que, se alguém alterar o método, por exemplo, mudando o sinal de adição para multiplicação, o teste apontará o erro na implementação. Veja como uma alteração no código poderia ocorrer:

return a * b;

Essa mudança de adição para multiplicação é um exemplo de como um teste automatizado pode detectar erros na lógica do código. O teste manual tem seu valor, mas precisamos saber quando utilizá-lo, quando automatizar o teste e quando realizá-lo manualmente. Se envolve uma avaliação mais especializada, precisaremos de testes manuais. Em cenários críticos, que envolvem a manipulação de muitos dados, é importante considerar testes automatizados e integrados, para evitar que muitos erros cheguem à produção.

Diferenciando teste de software e debug

Um erro comum é confundir teste com debug. Teste e debug são diferentes. O teste verifica se o programa está funcionando corretamente, conforme foi desenhado, e se atende aos requisitos. Já o debug é executado para encontrar um erro que não foi detectado no teste e acabou indo para a produção.

A diferença entre um teste e um debug reside no fato de que o teste é preventivo, enquanto o debug é realizado de forma corretiva. Partindo da premissa de que o teste é algo preventivo, encontramos diversos benefícios relacionados ao teste de software. Ele reduz o custo com a correção de bugs e aumenta a confiança no código. Assim, quando formos fazer o deploy de uma nova versão do nosso aplicativo ou sistema, estaremos mais confiantes de que funcionará corretamente e não introduzirá novos erros.

Benefícios e importância dos testes de software

O teste também facilita a refatoração, pois, se já existe um teste realizado anteriormente, isso auxilia a pessoa que precisar reescrever ou implementar algo novo a entender qual era a regra de negócio existente e a cumprir as condições daquele teste. Além disso, ajuda a documentar o sistema em relação ao comportamento esperado.

Outro ponto importante é que, quanto mais cedo conseguirmos detectar um erro no nosso sistema, menor será o custo para corrigi-lo. Por exemplo, se detectamos o erro durante o levantamento de requisitos de desenvolvimento, o custo para resolvê-lo será menor, pois isso ocorre dentro do cronograma do projeto, permitindo ajustar os rumos e fazer as correções necessárias. No entanto, se o erro é detectado quando o software é disponibilizado para testes, o custo já é mais elevado devido à pressão do cronograma para o lançamento de um produto ou promoção de um e-commerce. Nesse caso, pode ser necessário mais pessoal para ajudar na correção dos erros, além da equipe já envolvida no projeto, ou a equipe pode precisar fazer horas extras.

Consequências de erros em produção

Pior ainda é se o erro ocorre em produção. Imagine ser responsável por um e-commerce que começa a apresentar erros. Isso não só gera custos com pessoal para corrigir os bugs, mas também prejuízos reais em vendas e na credibilidade do produto. Portanto, no desenvolvimento de software, devemos tentar detectar problemas e erros o quanto antes, corrigindo-os para evitar que cheguem à produção e se tornem ainda mais custosos para o nosso produto.

Concluindo a importância dos testes

Resumindo, testar software é verificar se o código está cumprindo sua função. É uma prática essencial para quem deseja desenvolver software com qualidade. É importante entender que nem todo problema encontrado no software é igual. Às vezes, o problema está na execução do código, outras vezes no próprio código ou na especificação.

No próximo vídeo, vamos entender melhor o significado de erro, defeito e falha, como identificá-los e, a partir dessa identificação, criar a melhor estratégia de teste e correção. Nos vemos lá.

Testes de software: o que, por que e quando testar - Defeitos, falhas e erros

Discutindo a importância dos testes de software

Na última aula, discutimos o que é um teste de software e sua finalidade. Ele serve para verificar se o código realiza as funções para as quais foi especificado. No entanto, surge a questão: o que fazer quando algo dá errado? Precisamos identificar exatamente o que deu errado, pois o problema nem sempre está no mesmo lugar. Pode ser um defeito no código, um erro humano durante a programação ou uma falha na execução do código. É sobre isso que vamos falar agora.

Os termos "defeito", "erro" e "falha" são frequentemente utilizados quando falamos sobre testes de software. Compreender bem o significado desses termos ajuda na comunicação dentro da equipe. Saber o que é uma falha, um defeito e um erro permite que a equipe se comunique melhor e trabalhe na correção desses problemas.

Explicando a diferença entre falha, defeito e erro

Uma falha é o problema que ocorre durante a execução do código. É o que percebemos de errado na aplicação. No entanto, essa falha é apenas a ponta do iceberg. Ela pode ter sido provocada por um defeito no código, algo que não foi bem escrito ou previsto, ou que não foi tratado adequadamente. Esse defeito, por sua vez, pode ter sido introduzido por um erro humano, como uma falha na especificação, um erro no entendimento da especificação ou um erro na escrita do código. Precisamos identificar onde está o problema para corrigi-lo de forma mais eficiente.

Demonstrando o uso da função de divisão

Vamos ao Visual Studio novamente, onde temos um método de divisão que divide um número pelo outro, ou seja, divide o número A pelo número B. O código parece correto à primeira vista. Se temos o número A e o número B, basta dividir A por B.

Aqui está o método inicial que realiza essa divisão:

public static double Dividir(double a, double b)
{
    return a / b;
}

No entanto, se o valor de B for 0, o que acontecerá? Logicamente, teremos um erro, pois nenhum número pode ser dividido por 0. Será que o programador esqueceu de tratar essa situação? Se o programador esqueceu de adicionar esse tratamento no código, foi um erro humano. A ausência dessa verificação no código representa um defeito.

Analisando a importância da prevenção de falhas

Durante a execução, no momento em que alguém informar que o valor de B é 0, será disparada uma exceção de divisão por 0, resultando na falha do nosso programa. Entender a diferença entre esses termos é crucial para identificarmos a causa raiz do problema. O que ocorreu? Foi uma especificação mal feita? Um requisito mal interpretado? A lógica foi implementada de forma errada? Ou algo que o teste não cobriu, que não conseguimos prever?

Quando falamos de qualidade de software, o foco não é apenas encontrar falhas, mas evitar que erros humanos se transformem em defeitos. Ao falarmos de teste, estamos realmente tratando de prevenção. Evitamos que algum descompasso na definição de requisitos ou mal-entendidos na interpretação se tornem falhas no sistema. Compreender a diferença entre erro, defeito e falha é importante para encontrar a causa raiz e investigar o ocorrido. Pode ser um erro de lógica, um requisito mal interpretado ou algo que o teste não cobriu.

Resumindo a relação entre erro, defeito e falha

Além disso, quando falamos de qualidade, o foco não é apenas encontrar falhas no programa, mas evitar que erros humanos se transformem em defeitos no código, resultando em falhas. Por isso, boas práticas, revisões de código e testes automatizados são fundamentais para reduzir a chance de um erro ocasionar um defeito que gerará uma falha, visível ao usuário.

Resumindo, o erro é humano e ocorre quando interpretamos ou implementamos algo incorretamente. O defeito é o reflexo desse erro no código. A falha é o que o usuário percebe quando esse defeito se manifesta na execução. Compreender essas diferenças ajuda a saber onde agir, seja no código, no processo ou na comunicação dentro da equipe.

Introduzindo o planejamento e execução de testes

Com isso em mente, podemos imaginar que existem diferentes formas de planejar e executar um teste. É justamente sobre isso que vamos conversar no próximo vídeo.

Sobre o curso Testes em .NET: fundamentos, boas práticas e automação em pipelines CI/CD

O curso Testes em .NET: fundamentos, boas práticas e automação em pipelines CI/CD possui 198 minutos de vídeos, em um total de 48 atividades. Gostou? Conheça nossos outros cursos de .NET em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Testes de software: o que, por que e quando testar
• Ampliando os testes: do código à aplicação
• Automação de testes e integração contínua
• Além do código: ampliando a qualidade de software