Moq C# (Como funciona para desenvolvedores)

Criar um novo projeto C

Siga os passos abaixo para criar um novo projeto:

1. Abra o Visual Studio , vá em "Arquivo" > "Novo" > "Projeto...".
2. Escolha um modelo de projeto, configure as definições e clique em "Criar".

Suponha que você esteja desenvolvendo um software para um caixa eletrônico (ATM) e precise testar as funcionalidades de autenticação e saque. O caixa eletrônico depende de duas interfaces: IHostBank e IHSMModule. Queremos testar a classe ATMCashWithdrawal, que representa a funcionalidade de saque de dinheiro do caixa eletrônico.

Crie duas interfaces, IHostBank e IHSMModule, que representam as dependências do sistema ATM. Defina métodos relevantes como AuthenticateAmount e ValidatePIN.

// IHostBank.cs
public interface IHostBank
{
    bool AuthenticateAmount(string accountNumber, int amount);
}

// IHSMModule.cs
public interface IHSMModule
{
    bool ValidatePIN(string cardNumber, int pin);
}

// IHostBank.cs
public interface IHostBank
{
    bool AuthenticateAmount(string accountNumber, int amount);
}

// IHSMModule.cs
public interface IHSMModule
{
    bool ValidatePIN(string cardNumber, int pin);
}

' IHostBank.cs
Public Interface IHostBank
	Function AuthenticateAmount(ByVal accountNumber As String, ByVal amount As Integer) As Boolean
End Interface

' IHSMModule.cs
Public Interface IHSMModule
	Function ValidatePIN(ByVal cardNumber As String, ByVal pin As Integer) As Boolean
End Interface

Crie a classe ATMCashWithdrawal, que utiliza as dependências mencionadas acima para realizar operações de caixa eletrônico. Nesta aula, você implementará um determinado método como WithdrawAmount.

// ATMCashWithdrawal.cs
public class ATMCashWithdrawal
{
    private readonly IHSMModule hsmModule;
    private readonly IHostBank hostBank;

    public ATMCashWithdrawal(IHSMModule hsmModule, IHostBank hostBank)
    {
        this.hsmModule = hsmModule;
        this.hostBank = hostBank;
    }

    // Withdraw amount after validating PIN and balance
    public bool WithdrawAmount(string cardNumber, int pin, int amount)
    {
        if (!hsmModule.ValidatePIN(cardNumber, pin))
        {
            return false;
        }

        if (!hostBank.AuthenticateAmount(cardNumber, amount))
        {
            return false;
        }

        // Withdraw the specified amount and perform other operations
        return true;
    }
}

// ATMCashWithdrawal.cs
public class ATMCashWithdrawal
{
    private readonly IHSMModule hsmModule;
    private readonly IHostBank hostBank;

    public ATMCashWithdrawal(IHSMModule hsmModule, IHostBank hostBank)
    {
        this.hsmModule = hsmModule;
        this.hostBank = hostBank;
    }

    // Withdraw amount after validating PIN and balance
    public bool WithdrawAmount(string cardNumber, int pin, int amount)
    {
        if (!hsmModule.ValidatePIN(cardNumber, pin))
        {
            return false;
        }

        if (!hostBank.AuthenticateAmount(cardNumber, amount))
        {
            return false;
        }

        // Withdraw the specified amount and perform other operations
        return true;
    }
}

' ATMCashWithdrawal.cs
Public Class ATMCashWithdrawal
	Private ReadOnly hsmModule As IHSMModule
	Private ReadOnly hostBank As IHostBank

	Public Sub New(ByVal hsmModule As IHSMModule, ByVal hostBank As IHostBank)
		Me.hsmModule = hsmModule
		Me.hostBank = hostBank
	End Sub

	' Withdraw amount after validating PIN and balance
	Public Function WithdrawAmount(ByVal cardNumber As String, ByVal pin As Integer, ByVal amount As Integer) As Boolean
		If Not hsmModule.ValidatePIN(cardNumber, pin) Then
			Return False
		End If

		If Not hostBank.AuthenticateAmount(cardNumber, amount) Then
			Return False
		End If

		' Withdraw the specified amount and perform other operations
		Return True
	End Function
End Class

Criar um projeto de teste unitário

Agora, vamos criar testes unitários para a classe ATMCashWithdrawal usando MOQ para simular as dependências.

Crie um novo projeto de teste de unidade em sua solução e nomeie-o como ATMSystem.Tests.

Para adicionar um projeto de teste NUnit à sua solução do Visual Studio, siga estes passos:

1. Clique com o botão direito do mouse na solução: No Explorador de Soluções (geralmente localizado no lado direito), clique com o botão direito do mouse no nome da solução.
2. Adicionar > Novo Projeto: No menu de contexto, selecione "Adicionar" e depois "Novo Projeto...".
3. Criar um novo projeto: Na caixa de diálogo "Adicionar novo projeto", você pode pesquisar por "NUnit" para encontrar modelos NUnit disponíveis. Selecione o projeto de teste NUnit conforme mostrado abaixo.

4. Configurar o projeto: Configure as definições do projeto conforme necessário, incluindo o nome e a localização do projeto.
5. Clique em OK: Clique no botão "Criar" ou "OK" para adicionar o projeto de teste NUnit à sua solução.

Agora você tem um projeto de teste NUnit separado dentro da sua solução, onde pode escrever e gerenciar seus testes unitários. Você também pode adicionar referências aos projetos que deseja testar e começar a escrever seus casos de teste NUnit neste projeto.

Para começar a usar o MOQ no projeto de teste, você precisará adicionar o pacote NuGet do MOQ à sua solução. Você pode fazer isso usando o Gerenciador de Pacotes NuGet no Visual Studio ou executando o seguinte comando no Console do Gerenciador de Pacotes:

Install-Package Moq

Este comando instalará o pacote e adicionará todas as dependências necessárias ao projeto.

Escreva testes unitários usando NUnit e MOQ para simular as dependências (IHostBank e IHSMModule) da classe ATMCashWithdrawal.

using Moq;
using NUnit.Framework;

namespace ATMSystem.Tests
{
    public class ATMTests
    {
        private ATMCashWithdrawal atmCash;

        [SetUp]
        public void Setup()
        {
            // Arrange - Setup mock objects
            var hsmModuleMock = new Mock<IHSMModule>();
            hsmModuleMock.Setup(h => h.ValidatePIN("123456781234", 1234)).Returns(true);

            var hostBankMock = new Mock<IHostBank>();
            hostBankMock.Setup(h => h.AuthenticateAmount("123456781234", 500)).Returns(true);

            atmCash = new ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object);
        }

        [Test]
        public void WithdrawAmount_ValidTransaction_ReturnsTrue()
        {
            // Act - Execute the method under test
            bool result = atmCash.WithdrawAmount("123456781234", 1234, 500);

            // Assert - Verify the result
            Assert.IsTrue(result);
        }

        // More test cases for different scenarios (e.g., invalid PIN, insufficient funds)
    }
}

using Moq;
using NUnit.Framework;

namespace ATMSystem.Tests
{
    public class ATMTests
    {
        private ATMCashWithdrawal atmCash;

        [SetUp]
        public void Setup()
        {
            // Arrange - Setup mock objects
            var hsmModuleMock = new Mock<IHSMModule>();
            hsmModuleMock.Setup(h => h.ValidatePIN("123456781234", 1234)).Returns(true);

            var hostBankMock = new Mock<IHostBank>();
            hostBankMock.Setup(h => h.AuthenticateAmount("123456781234", 500)).Returns(true);

            atmCash = new ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object);
        }

        [Test]
        public void WithdrawAmount_ValidTransaction_ReturnsTrue()
        {
            // Act - Execute the method under test
            bool result = atmCash.WithdrawAmount("123456781234", 1234, 500);

            // Assert - Verify the result
            Assert.IsTrue(result);
        }

        // More test cases for different scenarios (e.g., invalid PIN, insufficient funds)
    }
}

Imports Moq
Imports NUnit.Framework

Namespace ATMSystem.Tests
	Public Class ATMTests
		Private atmCash As ATMCashWithdrawal

		<SetUp>
		Public Sub Setup()
			' Arrange - Setup mock objects
			Dim hsmModuleMock = New Mock(Of IHSMModule)()
			hsmModuleMock.Setup(Function(h) h.ValidatePIN("123456781234", 1234)).Returns(True)

			Dim hostBankMock = New Mock(Of IHostBank)()
			hostBankMock.Setup(Function(h) h.AuthenticateAmount("123456781234", 500)).Returns(True)

			atmCash = New ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object)
		End Sub

		<Test>
		Public Sub WithdrawAmount_ValidTransaction_ReturnsTrue()
			' Act - Execute the method under test
			Dim result As Boolean = atmCash.WithdrawAmount("123456781234", 1234, 500)

			' Assert - Verify the result
			Assert.IsTrue(result)
		End Sub

		' More test cases for different scenarios (e.g., invalid PIN, insufficient funds)
	End Class
End Namespace

Neste código de teste, estamos usando o MOQ para criar objetos simulados para IHSMModule e IHostBank e especificando seu comportamento quando chamados durante o teste.

No exemplo de código acima, demonstramos o conceito de simulação de objetos usando MOQ em C#. Criamos objetos simulados para as interfaces IHSMModule e IHostBank, simulando seu comportamento durante os testes unitários. Isso nos permite isolar e testar minuciosamente a classe ATMCashWithdrawal controlando as respostas desses objetos simulados. Por meio de simulações (mocking), podemos garantir que nosso código interaja corretamente com essas dependências, tornando nossos testes focados, previsíveis e eficazes na identificação de problemas dentro da unidade de código específica em análise. Essa prática melhora a confiabilidade geral, a facilidade de manutenção e a qualidade do código de teste.

Etapa 3: Executando os testes

1. Elabore sua solução garantindo que tudo esteja atualizado.
2. Abra o Explorador de Testes no Visual Studio (Teste > Explorador de Testes).
3. Clique no botão "Executar tudo" no Explorador de Testes para executar seus testes unitários.
4. Analise os resultados dos testes. Você deverá ver o teste que você escreveu (WithdrawAmount_ValidTransaction_ReturnsTrue) passar.

Dessa forma, podemos isolar o código que queremos testar e garantir que ele se comporte conforme o esperado em vários cenários, simulando efetivamente as dependências. Essa prática melhora a confiabilidade e a facilidade de manutenção do seu software, tornando mais fácil identificar e corrigir problemas no início do processo de desenvolvimento.

Criar objetos simulados para gerar PDFs

Suponha que você esteja desenvolvendo um aplicativo que gera relatórios financeiros e que esses relatórios precisem ser salvos e distribuídos como documentos PDF. Nesse cenário, talvez você queira testar a geração do PDF e garantir que o conteúdo e a formatação estejam corretos.

Primeiro, precisamos adicionar o IronPDF ao nosso projeto. Digite o seguinte comando no Console do Gerenciador de Pacotes NuGet para instalar o IronPDF.

Install-Package IronPdf

Este comando instalará e adicionará as dependências necessárias ao nosso projeto.

Eis como o IronPDF pode ser incorporado ao processo de teste unitário:

Geração de PDFs de teste

Você pode usar o IronPDF para criar documentos PDF simulados com conteúdo e estilo específicos, imitando relatórios financeiros reais. Esses PDFs simulados podem servir como modelos de teste para seus testes unitários, conforme mostrado no trecho de código a seguir:

public class PDFGenerator
{
    public void GenerateFinancialReport(string reportData)
    {
        var renderer = new ChromePdfRenderer();

        // Generate the report HTML
        string reportHtml = GenerateReportHtml(reportData);
        PdfDocument pdfDocument = renderer.RenderHtmlAsPdf(reportHtml);

        // Save the PDF to a file or memory stream
        pdfDocument.SaveAs("FinancialReport.pdf");
    }

    private string GenerateReportHtml(string reportData)
    {
        // Generate the report HTML based on the provided data
        // (e.g., using Razor views or any HTML templating mechanism)
        // Return the HTML as a string
        return "<h1>my Report</h1>";
    }
}

public class PDFGenerator
{
    public void GenerateFinancialReport(string reportData)
    {
        var renderer = new ChromePdfRenderer();

        // Generate the report HTML
        string reportHtml = GenerateReportHtml(reportData);
        PdfDocument pdfDocument = renderer.RenderHtmlAsPdf(reportHtml);

        // Save the PDF to a file or memory stream
        pdfDocument.SaveAs("FinancialReport.pdf");
    }

    private string GenerateReportHtml(string reportData)
    {
        // Generate the report HTML based on the provided data
        // (e.g., using Razor views or any HTML templating mechanism)
        // Return the HTML as a string
        return "<h1>my Report</h1>";
    }
}

Public Class PDFGenerator
	Public Sub GenerateFinancialReport(ByVal reportData As String)
		Dim renderer = New ChromePdfRenderer()

		' Generate the report HTML
		Dim reportHtml As String = GenerateReportHtml(reportData)
		Dim pdfDocument As PdfDocument = renderer.RenderHtmlAsPdf(reportHtml)

		' Save the PDF to a file or memory stream
		pdfDocument.SaveAs("FinancialReport.pdf")
	End Sub

	Private Function GenerateReportHtml(ByVal reportData As String) As String
		' Generate the report HTML based on the provided data
		' (e.g., using Razor views or any HTML templating mechanism)
		' Return the HTML as a string
		Return "<h1>my Report</h1>"
	End Function
End Class

Testes unitários com PDFs simulados

Vamos escrever testes para usar o IronPDF para gerar PDFs simulados que representem vários cenários de relatório. Em seguida, compararemos os PDFs reais gerados pelo nosso código com esses PDFs simulados para garantir que o conteúdo, a formatação e a estrutura estejam conforme o esperado.

using IronPdf;
using NUnit.Framework;

internal class PDFGeneratorTests
{
    [Test]
    public void GenerateFinancialReport_CreatesCorrectPDF()
    {
        // Arrange
        var pdfGenerator = new PDFGenerator();
        var expectedPdf = PdfDocument.FromFile("ExpectedFinancialReport.pdf"); // Load a mock PDF

        // Act
        pdfGenerator.GenerateFinancialReport("Sample report data");
        var actualPdf = PdfDocument.FromFile("FinancialReport.pdf");

        // Assert
        Assert.AreEqual(actualPdf.ExtractAllText(), expectedPdf.ExtractAllText());
    }
}

using IronPdf;
using NUnit.Framework;

internal class PDFGeneratorTests
{
    [Test]
    public void GenerateFinancialReport_CreatesCorrectPDF()
    {
        // Arrange
        var pdfGenerator = new PDFGenerator();
        var expectedPdf = PdfDocument.FromFile("ExpectedFinancialReport.pdf"); // Load a mock PDF

        // Act
        pdfGenerator.GenerateFinancialReport("Sample report data");
        var actualPdf = PdfDocument.FromFile("FinancialReport.pdf");

        // Assert
        Assert.AreEqual(actualPdf.ExtractAllText(), expectedPdf.ExtractAllText());
    }
}

Imports IronPdf
Imports NUnit.Framework

Friend Class PDFGeneratorTests
	<Test>
	Public Sub GenerateFinancialReport_CreatesCorrectPDF()
		' Arrange
		Dim pdfGenerator As New PDFGenerator()
		Dim expectedPdf = PdfDocument.FromFile("ExpectedFinancialReport.pdf") ' Load a mock PDF

		' Act
		pdfGenerator.GenerateFinancialReport("Sample report data")
		Dim actualPdf = PdfDocument.FromFile("FinancialReport.pdf")

		' Assert
		Assert.AreEqual(actualPdf.ExtractAllText(), expectedPdf.ExtractAllText())
	End Sub
End Class

Neste código de teste, geramos um PDF simulado (expectedPdf) representando a saída esperada e o comparamos com o PDF (actualPdf) gerado pelo PDFGenerator. Extraímos o conteúdo de ambos os PDFs para verificar se eles possuem o mesmo conteúdo.