Testes unitários em C# (Como funciona para desenvolvedores)

Criando um projeto de teste unitário

Para começar a fazer testes unitários em C#, você precisará configurar um dos projetos de teste unitário no Visual Studio. O Visual Studio oferece uma estrutura de testes unitários integrada, facilitando o início do trabalho. Ao criar um novo projeto, selecione o modelo "Projeto de Teste Unitário" na categoria C#. Este modelo configura tudo o que você precisa para criar testes unitários e executá-los com eficiência.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace Unit_Test_Project_Example
{
    // A simple calculator class with an Add method
    public class Calculator
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }

    // A test class to validate the functionality of the Calculator class
    [TestClass]
    public class CalculatorTests
    {
        // A test method to check if the Add method in Calculator returns the correct sum
        [TestMethod]
        public void Add_ShouldReturnCorrectSum()
        {
            // Arrange
            var calculator = new Calculator();

            // Act
            var result = calculator.Add(2, 2);

            // Assert
            Assert.AreEqual(4, result);
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace Unit_Test_Project_Example
{
    // A simple calculator class with an Add method
    public class Calculator
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }

    // A test class to validate the functionality of the Calculator class
    [TestClass]
    public class CalculatorTests
    {
        // A test method to check if the Add method in Calculator returns the correct sum
        [TestMethod]
        public void Add_ShouldReturnCorrectSum()
        {
            // Arrange
            var calculator = new Calculator();

            // Act
            var result = calculator.Add(2, 2);

            // Assert
            Assert.AreEqual(4, result);
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports System

Namespace Unit_Test_Project_Example
	' A simple calculator class with an Add method
	Public Class Calculator
		Public Function Add(ByVal a As Integer, ByVal b As Integer) As Integer
			Return a + b
		End Function
	End Class

	' A test class to validate the functionality of the Calculator class
	<TestClass>
	Public Class CalculatorTests
		' A test method to check if the Add method in Calculator returns the correct sum
		<TestMethod>
		Public Sub Add_ShouldReturnCorrectSum()
			' Arrange
			Dim calculator As New Calculator()

			' Act
			Dim result = calculator.Add(2, 2)

			' Assert
			Assert.AreEqual(4, result)
		End Sub
	End Class
End Namespace

Compreendendo os métodos de teste e as classes de teste

Em um projeto de teste unitário, você organiza os testes em classes e métodos. Uma classe de teste representa uma coleção de métodos de teste unitário que devem ser executados em conjunto. Cada método de teste unitário, decorado com o atributo [TestMethod] , contém a lógica para testar uma função específica do seu código. A própria classe de teste é marcada com o atributo [TestClass] , sinalizando para a estrutura de testes que ela contém testes a serem executados.

Usando o Explorador de Testes no Visual Studio

A janela do Explorador de Testes do Visual Studio é o seu centro de operações para executar e gerenciar todos os métodos de teste. Você pode executar todos os testes, uma seleção de testes ou testes individuais. Após a execução dos testes, o Explorador de Testes fornece um resumo detalhado dos testes aprovados e reprovados, permitindo que você identifique e resolva problemas rapidamente.

Interpretação dos resultados dos testes

• Testes Aprovados: Esses testes foram executados com sucesso, indicando que o código testado se comporta conforme o esperado nas condições especificadas.
• Testes com falha: Indicam uma discrepância entre os resultados esperados e os reais, sinalizando possíveis erros ou mal-entendidos nos requisitos ou no código de teste.

É essencial investigar prontamente os testes com falha, pois eles podem fornecer sinais de alerta precoce de problemas em sua base de código.

Organizando testes de forma eficaz

Uma boa organização é fundamental para manter um grande conjunto de testes. Agrupe seus testes logicamente pela funcionalidade que eles abrangem. Utilize nomes descritivos para seus métodos e classes de teste para indicar o que cada teste está verificando. Essa abordagem facilita a localização e a compreensão dos testes posteriormente, especialmente à medida que seu conjunto de testes aumenta.

Simulação e Injeção de Dependência

Frequentemente, o código que você está testando interage com recursos externos ou outras partes do seu aplicativo. Nesses casos, utilize frameworks de mocking como Moq ou NSubstitute para criar objetos mock. Esses objetos substitutos imitam o comportamento dos objetos reais, permitindo que você teste seu código isoladamente. A injeção de dependências torna seu código mais testável, pois permite substituir dependências reais por mocks ou stubs durante os testes.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

// A sample test class demonstrating the use of mocks
[TestClass]
public class ProductServiceTests
{
    // A test method to verify the GetProductById method of ProductService
    [TestMethod]
    public void GetProductById_ShouldReturnCorrectProduct()
    {
        // Arrange
        var mockRepository = new Mock<IProductRepository>();
        mockRepository.Setup(x => x.FindById(1)).Returns(new Product { Id = 1, Name = "Laptop" });

        ProductService productService = new ProductService(mockRepository.Object);

        // Act
        Product result = productService.GetProductById(1);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual("Laptop", result.Name);
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

// A sample test class demonstrating the use of mocks
[TestClass]
public class ProductServiceTests
{
    // A test method to verify the GetProductById method of ProductService
    [TestMethod]
    public void GetProductById_ShouldReturnCorrectProduct()
    {
        // Arrange
        var mockRepository = new Mock<IProductRepository>();
        mockRepository.Setup(x => x.FindById(1)).Returns(new Product { Id = 1, Name = "Laptop" });

        ProductService productService = new ProductService(mockRepository.Object);

        // Act
        Product result = productService.GetProductById(1);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual("Laptop", result.Name);
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports Moq

' A sample test class demonstrating the use of mocks
<TestClass>
Public Class ProductServiceTests
	' A test method to verify the GetProductById method of ProductService
	<TestMethod>
	Public Sub GetProductById_ShouldReturnCorrectProduct()
		' Arrange
		Dim mockRepository = New Mock(Of IProductRepository)()
		mockRepository.Setup(Function(x) x.FindById(1)).Returns(New Product With {
			.Id = 1,
			.Name = "Laptop"
		})

		Dim productService As New ProductService(mockRepository.Object)

		' Act
		Dim result As Product = productService.GetProductById(1)

		' Assert
		Assert.IsNotNull(result)
		Assert.AreEqual("Laptop", result.Name)
	End Sub
End Class

Utilizando testes orientados por dados

Os testes orientados por dados permitem executar o mesmo método de teste várias vezes com diferentes dados de entrada. Essa técnica é particularmente útil para testar uma ampla gama de entradas e cenários sem a necessidade de escrever múltiplos métodos de teste. O Visual Studio oferece suporte a testes orientados a dados, permitindo que você especifique seus dados de teste a partir de várias fontes, como dados embutidos, arquivos CSV ou bancos de dados.

Entendendo e usando asserções de forma eficaz

As asserções são o coração dos seus métodos de teste, pois validam os resultados dos seus testes. Compreenda a variedade de métodos de asserção disponíveis em sua estrutura de testes e use-os adequadamente para verificar valores esperados, exceções ou condições. Usar a assert correta pode tornar seus testes mais claros e robustos.

Integração Contínua e Automação de Testes

Integre seus testes unitários ao seu pipeline de integração contínua (CI). Isso garante que os testes sejam executados automaticamente sempre que houver alterações no código-fonte, ajudando a detectar e corrigir problemas precocemente. A automação também facilita a execução de testes com frequência e consistência, o que é crucial para manter uma base de código saudável.

Manter os testes e o código de produção sincronizados

A qualidade dos seus testes unitários depende da sua compatibilidade com o código de produção. Assegure-se de que quaisquer alterações na funcionalidade sejam refletidas nos testes unitários correspondentes. Essa prática impede que testes desatualizados sejam aprovados incorretamente e garante que seu conjunto de testes represente com precisão o estado da sua aplicação.

Aprendendo com os erros em testes

Quando um teste falha, é uma oportunidade para aprender e melhorar. Um teste com falha pode revelar comportamentos inesperados, suposições incorretas ou áreas do seu código que são mais complexas e propensas a erros do que o necessário. Analise cuidadosamente os testes com falha para entender suas causas subjacentes e use essas informações para aprimorar tanto seus testes quanto seu código de produção.

Exemplo de código

Aqui está um exemplo de como você pode usar o IronPDF em um cenário de teste unitário em C#. Suponha que você queira testar uma função que gera um PDF a partir de conteúdo HTML. Você pode usar o IronPDF para renderizar o HTML como um PDF e, em seguida, verificar a existência ou o conteúdo do PDF como parte do seu teste:

using IronPdf;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;

// A sample test class to verify PDF generation
[TestClass]
public class PdfGenerationTests
{
    // A test method to verify HTML to PDF generation using IronPDF
    [TestMethod]
    public void TestHtmlToPdfGeneration()
    {
        IronPdf.License.LicenseKey = "License-Key"; // Set your IronPDF license key

        var renderer = new ChromePdfRenderer();

        // Render HTML to a PDF
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, world!</h1>");

        string filePath = Path.Combine(Path.GetTempPath(), "test.pdf");

        // Save the generated PDF to a file
        pdf.SaveAs(filePath);

        // Assert the PDF file was created successfully
        Assert.IsTrue(File.Exists(filePath), "The generated PDF does not exist.");

        // Additional assertions to verify the PDF content could be added here
        // Clean up generated file
        File.Delete(filePath);
    }
}

using IronPdf;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;

// A sample test class to verify PDF generation
[TestClass]
public class PdfGenerationTests
{
    // A test method to verify HTML to PDF generation using IronPDF
    [TestMethod]
    public void TestHtmlToPdfGeneration()
    {
        IronPdf.License.LicenseKey = "License-Key"; // Set your IronPDF license key

        var renderer = new ChromePdfRenderer();

        // Render HTML to a PDF
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, world!</h1>");

        string filePath = Path.Combine(Path.GetTempPath(), "test.pdf");

        // Save the generated PDF to a file
        pdf.SaveAs(filePath);

        // Assert the PDF file was created successfully
        Assert.IsTrue(File.Exists(filePath), "The generated PDF does not exist.");

        // Additional assertions to verify the PDF content could be added here
        // Clean up generated file
        File.Delete(filePath);
    }
}

Imports IronPdf
Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports System
Imports System.IO

' A sample test class to verify PDF generation
<TestClass>
Public Class PdfGenerationTests
	' A test method to verify HTML to PDF generation using IronPDF
	<TestMethod>
	Public Sub TestHtmlToPdfGeneration()
		IronPdf.License.LicenseKey = "License-Key" ' Set your IronPDF license key

		Dim renderer = New ChromePdfRenderer()

		' Render HTML to a PDF
		Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, world!</h1>")

		Dim filePath As String = Path.Combine(Path.GetTempPath(), "test.pdf")

		' Save the generated PDF to a file
		pdf.SaveAs(filePath)

		' Assert the PDF file was created successfully
		Assert.IsTrue(File.Exists(filePath), "The generated PDF does not exist.")

		' Additional assertions to verify the PDF content could be added here
		' Clean up generated file
		File.Delete(filePath)
	End Sub
End Class

Este exemplo demonstra um teste unitário simples que usa o IronPDF para gerar um PDF a partir de uma string HTML, salvá-lo em um arquivo temporário e, em seguida, verificar a existência do arquivo.