Aprimore Testes Unitários: Domine Moq para C# Hoje

Por que você vai amar o Moq? Imagine testar um carro sem ligar o motor de verdade. O Moq é o seu "dublê de ação" para dependências externas, permitindo testar componentes isoladamente, sem riscos! Vamos desvendar essa ferramenta essencial para🔄 Loops em C#: Repita Tarefas sem Enlouquecer (Com for e while!)Descubra como automatizar repetições em C# utilizando loops for e while com exemplos práticos que evitam erros e otimizam seu código. Aprenda mais! testes robustos em C#.

// Exemplo rápido:
var mock = new Mock<ICalculadora>();
mock.Setup(c => c.Somar(2, 2)).Returns(4);

📚 Conteúdo🔗

🚀 Por que simular dependências?🔗

Imagine que você tem um serviço que consulta🎲 Desafio: Analise Dados de Vendas com LINQ e Coleções!Aprenda a usar coleções e LINQ em C# para analisar vendas, filtrar dados e extrair insights estratégicos que otimizem decisões e impulsionem seu negócio. um serviço de pagamentos externo ou envia e-mails para clientes. Para testar seu código sem precisar de fato enviar transações ou e-mails de verdade (o que seria lento, caro e até arriscado), você pode simular esses comportamentos internamente. É aqui que entra o Moq, uma biblioteca que ajuda a criar “cópias genéricas” (mocks) de interfaces📜 Interfaces: Contratos que Garantem a Ordem no Universo OOP!Descubra como as interfaces em C# funcionam como contratos que garantem implementações flexíveis e robustas, facilitando o design e testes de sistemas. ou classes para isolar a lógica que você realmente deseja testar. Isso permite que seu teste seja rápido, previsível e focado na lógica do seu próprio código.

Cenário real: Você está testando um sistema de pedidos que depende de:

Problema🤝 GitHub Básico: Versionamento para Iniciantes!Descubra como o GitHub facilita colaboração, versionamento e organização de código com este tutorial prático e essencial para desenvolvedores iniciantes.: Testar tudo junto pode:

Tornar os testes lentos
Gerar falsos positivos (erro na API ≠ erro🎲 Desafio: Crie um Sistema de Login com Tratamento de Erros Robusto!Aprenda a criar um sistema de login robusto em C#, com tratamento de erros adequado, validação e segurança para evitar vulnerabilidades. no seu código)
Dificultar a identificação da causa raiz

Solução: Moq substitui essas dependências por versões controladas, como um dublê substitui um ator em cenas perigosas!

🛠️ Instalando o Moq🔗

Antes de usar o Moq, você vai precisar instalá-lo. Se estiver usando o .NET CLI, no seu projeto🤝 GitHub Básico: Versionamento para Iniciantes!Descubra como o GitHub facilita colaboração, versionamento e organização de código com este tutorial prático e essencial para desenvolvedores iniciantes. de testes, rode:

dotnet add package Moq

OU pelo NuGet📦 Crie um Pacote NuGet: Compartilhe seu Código!Aprenda a empacotar, configurar e publicar pacotes NuGet em C# passo a passo, com dicas profissionais e práticas recomendadas para seu projeto. Package Manager:

Install-Package Moq

Feito isso, você já está pronto para criar seus primeiros mocks e rodar testes unitários🧪 Testes de Unidade para Tratamento de Erros: Previna Falhas Futuras!Descubra como implementar testes de unidade focados em tratamento de erros, evitando surpresas em produção e garantindo sistemas confiáveis e robustos. com a ajuda do Moq.

🎬 Básico: Criando seu primeiro Mock🔗

O processo básico com Moq envolve:

1. Definir o objeto “falso” (mock).

2. Configurar como ele deve se comportar quando📊 Behavior-Driven Development: Testes que Todo Mundo Entende!Descubra como o BDD transforma testes em linguagens acessíveis. Aprenda a usar SpecFlow em C# para criar testes claros, colaborativos e sem ambiguidades. seus membros forem chamados.

Suponha que você tenha uma interface📜 Interfaces: Contratos que Garantem a Ordem no Universo OOP!Descubra como as interfaces em C# funcionam como contratos que garantem implementações flexíveis e robustas, facilitando o design e testes de sistemas. ICalculadoraImpostos que aplica imposto sobre vendas. Vamos criar um método🧠 Métodos em C#: Como Criar Funções que Não São Só Enfeites!Otimize seu código em C# com métodos inteligentes. Aprenda práticas de reutilização, sobrecarga e escopo para melhorar a clareza e a eficiência. que depende dela:

public interface ICalculadoraImpostos
{
    decimal CalcularImposto(decimal valor);
}
public class ServicoVendas
{
    private readonly ICalculadoraImpostos _calculadora;
    public ServicoVendas(ICalculadoraImpostos calculadora)
    {
        _calculadora = calculadora;
    }
    public decimal ExecutarVenda(decimal valor)
    {
        var imposto = _calculadora.CalcularImposto(valor);
        return valor + imposto;
    }
}

Agora, sem ter uma implementação real de ICalculadoraImpostos, podemos testar ServicoVendas usando Moq:

using Moq;
using Xunit; // Exemplo de teste, mas você pode usar outro framework
public class ServicoVendasTests
{
    [Fact]
    public void ExecutarVenda_DeveSomarImpostoAoValor()
    {
        // 1. Criar o Mock
        var mockCalculadora = new Mock<ICalculadoraImpostos>();
        // 2. Configurar o comportamento
        mockCalculadora
            .Setup(c => c.CalcularImposto(It.IsAny<decimal>()))
            .Returns(10m); // Sempre retorna 10 de imposto
        // 3. Passar o mock para a classe a ser testada
        var servico = new ServicoVendas(mockCalculadora.Object);
        // 4. Executar método de teste
        var resultado = servico.ExecutarVenda(100m);
        // 5. Validar comportamento (100 + 10 = 110)
        Assert.Equal(110m, resultado);
    }
}

No exemplo acima, nós:

Criamos um mock de ICalculadoraImpostos.
Definimos que sempre que CalcularImposto for chamado, deve retornar 10, independente do valor🗂️ Dicionários: Acesse Dados por Chaves como um Mestre dos HashMaps!Aprenda a usar dicionários em C# de modo prático e eficiente. Nosso tutorial mostra criação, acesso e otimização para manipular dados com segurança. inicial.
Testamos se ExecutarVenda soma🔢 Operadores Aritméticos: Faça Cálculos como uma Calculadora Humana!Aprenda a dominar operadores aritméticos em C# com exemplos práticos, técnicas de cálculo e dicas para evitar erros e maximizar resultados. corretamente o imposto retornado, conforme nossa lógica.

🎭 Simulando comportamentos complexos🔗

1. Retornos dinâmicos:

mock.Setup(x => x.GetTotal())
    .Returns(() => DateTime.Now.Hour < 12 ? 100 : 200);

2. Lançando exceções:

mock.Setup(x => x.Processar())
    .Throws(new InvalidOperationException("Erro simulado!"));

3. Callbacks:

mock.Setup(x => x.Salvar(It.IsAny<string>()))
    .Callback<string>(nome => Console.WriteLine($"Salvando {nome}"))
    .Returns(true);

4. Propriedades:

mock.SetupProperty(x => x.Nome, "Padrão");
// OU
mock.SetupAllProperties(); // Configura todas as propriedades

🔍 Verificando interações🔗

Muitas vezes, além de simular um resultado, também queremos verificar se determinado método🧠 Métodos em C#: Como Criar Funções que Não São Só Enfeites!Otimize seu código em C# com métodos inteligentes. Aprenda práticas de reutilização, sobrecarga e escopo para melhorar a clareza e a eficiência. foi chamado (e quantas vezes). O Moq permite isso usando Verify:

mockCalculadora.Verify(
    c => c.CalcularImposto(It.IsAny<decimal>()),
    Times.Once
);

Isso vai falhar se CalcularImposto não for🔄 Loops em C#: Repita Tarefas sem Enlouquecer (Com for e while!)Descubra como automatizar repetições em C# utilizando loops for e while com exemplos práticos que evitam erros e otimizam seu código. Aprenda mais! chamado exatamente uma vez. Você também pode usar outras opções de verificação, como Times.Exactly(2) ou Times.Never.

Esse recurso é útil em cenários📊 Behavior-Driven Development: Testes que Todo Mundo Entende!Descubra como o BDD transforma testes em linguagens acessíveis. Aprenda a usar SpecFlow em C# para criar testes claros, colaborativos e sem ambiguidades. como: verificar se a classe chamou um método de envio de e-mail apenas se alguma condição do negócio fosse atendida, por exemplo.

⚡ Técnicas avançadas🔗

1. Argument Matching:

mock.Setup(x => x.Buscar(It.IsAny<int>())) // Qualquer inteiro
mock.Setup(x => x.Buscar(It.Is<int>(id => id > 0))) // Filtro customizado
mock.Setup(x => x.Buscar(It.IsInRange(1, 10, Moq.Range.Inclusive))) // Intervalo

2. Mocks em cadeia:

var mockDatabase = new Mock<IDatabase>();
mockDatabase.Setup(db => db.Usuarios)
            .Returns(new List<Usuario> { new Usuario("João") });
// Acessando propriedade que retorna outro serviço
mockDatabase.Setup(db => db.Logger)
            .Returns(new Mock<ILogger>().Object);

3. Mock de classes concretas (cuidado!):

var mockHttpClient = new Mock<HttpClient>();
// Requer métodos virtuais!

🚫 Armadilhas comuns (e como evitá-las)🔗

1. Over-mocking:

❌ Mockar tudo = testes frágeis
✅ Mocke apenas dependências externas

2. Setup incorreto:

// Errado:
mock.Setup(x => x.Somar(2, 2)).Returns(4);
// Correto:
mock.Setup(x => x.Somar(It.IsAny<int>(), It.IsAny<int>()))
    .Returns((int a, int b) => a + b);

3. Esquecer de verificar interações:

Use Verify() para🔄 Loops em C#: Repita Tarefas sem Enlouquecer (Com for e while!)Descubra como automatizar repetições em C# utilizando loops for e while com exemplos práticos que evitam erros e otimizam seu código. Aprenda mais! garantir que dependências foram chamadas corretamente

🏆 Desafio prático: Teste um serviço de pagamento🔗

Contexto:

public interface IPaymentGateway
{
    bool ProcessPayment(decimal amount, string cardNumber);
}
public class PaymentService
{
    private readonly IPaymentGateway _gateway;
    public PaymentService(IPaymentGateway gateway)
    {
        _gateway = gateway;
    }
    public string ExecutePayment(decimal amount, string cardNumber)
    {
        if (_gateway.ProcessPayment(amount, cardNumber))
        {
            return "SUCCESS";
        }
        return "FAILURE";
    }
}

Sua missão:

1. Criar testes para cenários📊 Behavior-Driven Development: Testes que Todo Mundo Entende!Descubra como o BDD transforma testes em linguagens acessíveis. Aprenda a usar SpecFlow em C# para criar testes claros, colaborativos e sem ambiguidades. de sucesso e falha

2. Verificar se o gateway foi chamado com os parâmetros🎯 Sobrecarga de Métodos: Um Nome, Múltiplos Superpoderes!Aprenda sobre a técnica de sobrecarga de métodos no C# com exemplos e práticas recomendadas para melhorar a organização e legibilidade do seu código. corretos

3. Simular uma exceção💥 Try/Catch: Domine Exceções antes que Elas Dominem Você!Descubra como tratar exceções em C# com práticas eficientes utilizando try/catch. Aprenda a gerenciar erros e aumentar a robustez do seu código. no gateway

4. Bônus: Testar valores🏗️ Classes vs. Structs: Quando Usar Cada Uma (e Não Quebrar a Cabeça)!Descubra como escolher entre classes e structs em C#. Aprenda sobre alocação de memória, passagem por valor e referência, e performance nesta explicação clara. limite (ex: amount <= 0)

// Comece aqui!
[Test]
public void Testar_Pagamento_Bem_Sucedido()
{
    // Seu código...
}

Próximo nível: Explore recursos📡 RESTful 101: Princípios que Todo Dev API Precisa Saber!Descubra os fundamentos do REST e boas práticas para criar APIs simples, escaláveis e eficientes. Domine métodos HTTP e status codes com exemplos práticos. como MockSequence para🔄 Loops em C#: Repita Tarefas sem Enlouquecer (Com for e while!)Descubra como automatizar repetições em C# utilizando loops for e while com exemplos práticos que evitam erros e otimizam seu código. Aprenda mais! verificar ordem de chamadas ou DefaultValueProvider para configurar valores🏗️ Classes vs. Structs: Quando Usar Cada Uma (e Não Quebrar a Cabeça)!Descubra como escolher entre classes e structs em C#. Aprenda sobre alocação de memória, passagem por valor e referência, e performance nesta explicação clara. padrão. O Moq é sua ferramenta para testes confiáveis e mantíveis! 🚀

Melhores Práticas

Prática	Benefício
Mockar apenas se necessário	Simplifica o teste, evitando criar mocks de qualquer dependência que não afete a lógica testada.
Especificar comportamentos claros	Facilita entender por que seu teste depende daquele resultado.
Verificar interações corretamente	Garante que os métodos foram chamados no número de vezes e na ordem esperada, se isso for relevante.
Limitar uso de mocks profundos	Evite “mocks de mocks”. Se sentir algo muito complexo, talvez o design do código precise ser simplificado.