Configurando o SpecFlow em projetos .NET

Para começar a usar o SpecFlow em seus projetos .NET , primeiro você precisa instalar o pacote NuGet do SpecFlow para configurar sua estrutura de testes, criar arquivos de recursos e definir cenários de teste.

1. Abra o Visual Studio.
2. Crie um novo projeto .NET ou abra um já existente.
3. Acesse o menu Extensões e, em seguida, Gerenciar extensões.
4. Pesquise por "Specflow". Instale a extensão Specflow.

Um exemplo de código básico

Após configurar o Specflow, você pode criar seu primeiro arquivo de recursos, que ficará localizado na pasta de recursos. Um arquivo de funcionalidades no SpecFlow descreve os comportamentos que você deseja testar em um formato legível. Aqui está um exemplo simples de como criar um novo arquivo de funcionalidades e definir cenários:

Feature: Login Feature
    Scenario: Successful Login with Valid Credentials
        Given I am on the login page
        When I enter valid credentials
        Then I should be redirected to the dashboard

Este arquivo de funcionalidades descreve um processo básico de login. Given prepara o cenário para o teste. When descreve a ação. Then define o resultado esperado. Você escreve essas declarações em inglês simples. Isso facilita a compreensão do fluxo e do propósito do teste.

Elaboração de testes com definições passo a passo

No Specflow, os testes são conduzidos por cenários descritos em arquivos de funcionalidades. Para tornar esses cenários executáveis, você precisa de definições de etapas. As definições de passos vinculam as etapas em linguagem natural ao código C#. Eis como você define as definições de etapas:

[Binding]
public class LoginSteps
{
    [Given(@"I am on the login page")]
    public void GivenIAmOnTheLoginPage()
    {
        // Code to navigate to the login page
    }

    [When(@"I enter valid credentials")]
    public void WhenIEnterValidCredentials()
    {
        // Code to input username and password
    }

    [Then(@"I should be redirected to the dashboard")]
    public void ThenIShouldBeRedirectedToTheDashboard()
    {
        // Code to verify the dashboard is displayed
    }
}

[Binding]
public class LoginSteps
{
    [Given(@"I am on the login page")]
    public void GivenIAmOnTheLoginPage()
    {
        // Code to navigate to the login page
    }

    [When(@"I enter valid credentials")]
    public void WhenIEnterValidCredentials()
    {
        // Code to input username and password
    }

    [Then(@"I should be redirected to the dashboard")]
    public void ThenIShouldBeRedirectedToTheDashboard()
    {
        // Code to verify the dashboard is displayed
    }
}

<Binding>
Public Class LoginSteps
	<Given("I am on the login page")>
	Public Sub GivenIAmOnTheLoginPage()
		' Code to navigate to the login page
	End Sub

	<[When]("I enter valid credentials")>
	Public Sub WhenIEnterValidCredentials()
		' Code to input username and password
	End Sub

	<[Then]("I should be redirected to the dashboard")>
	Public Sub ThenIShouldBeRedirectedToTheDashboard()
		' Code to verify the dashboard is displayed
	End Sub
End Class

Esta classe C# representa os passos do cenário de login. Cada método é etiquetado com um atributo Specflow correspondente ao tipo de etapa, como uma chave de texto para identificar etapas específicas.

Testes orientados por dados

O Specflow oferece suporte a testes orientados por dados, permitindo que você utilize diversos conjuntos de dados de teste em seus cenários. Isso permite testar cenários com vários conjuntos de dados. Aqui está um exemplo usando uma tabela em um arquivo de recursos:

Scenario: Login with multiple users
    Given I am on the login page
    When I login with the following credentials:
        | Username  | Password |
        | user1     | pass1    |
        | user2     | pass2    |
    Then I should see user specific dashboard

Nas definições dos seus passos, você pode acessar esses dados da seguinte forma:

[When(@"I login with the following credentials:")]
public void WhenILoginWithTheFollowingCredentials(Table table)
{
    foreach(var row in table.Rows)
    {
        string username = row["Username"];
        string password = row["Password"];
        // Code to perform login
    }
}

[When(@"I login with the following credentials:")]
public void WhenILoginWithTheFollowingCredentials(Table table)
{
    foreach(var row in table.Rows)
    {
        string username = row["Username"];
        string password = row["Password"];
        // Code to perform login
    }
}

<[When]("I login with the following credentials:")>
Public Sub WhenILoginWithTheFollowingCredentials(ByVal table As Table)
	For Each row In table.Rows
		Dim username As String = row("Username")
		Dim password As String = row("Password")
		' Code to perform login
	Next row
End Sub

Integração com o Test Explorer

O Specflow integra-se com o Explorador de Testes do Visual Studio, onde você pode executar e gerenciar todos os testes de forma eficiente. Isso facilita a execução e o gerenciamento de seus testes. Certifique-se de que seu projeto esteja configurado corretamente. Seus testes aparecerão no Explorador de Testes assim que você compilar o projeto. Você pode executar testes individuais ou todos os testes de uma só vez.

Execução de testes em paralelo

O SpecFlow suporta a execução de testes em paralelo para reduzir o tempo total de execução. Isso diminui o tempo necessário para executar todos os testes. Você precisa configurar seu arquivo specflow.json ou AssemblyInfo.cs para habilitar a execução paralela:

{
  "specFlow": {
    "runtime": {
      "testThreadCount": 4,
      "testSchedulingMode": "Parallel"
    }
  }
}

Essa configuração permite que até quatro testes sejam executados simultaneamente.

Ganchos personalizados

O Specflow permite que você defina hooks personalizados. Esses ganchos podem executar código em vários pontos do ciclo de vida do teste. Eis como você pode definir um gancho para configurar um banco de dados antes da execução de quaisquer testes:

[BeforeTestRun]
public static void SetUpDatabase()
{
    // Code to set up database
}

[BeforeTestRun]
public static void SetUpDatabase()
{
    // Code to set up database
}

<BeforeTestRun>
Public Shared Sub SetUpDatabase()
	' Code to set up database
End Sub

Ganchos personalizados são um recurso poderoso. Eles ajudam você a gerenciar os processos de configuração e desmontagem de testes.

Esta seção abordou cinco recursos principais do SpecFlow que podem aprimorar sua estrutura de testes em projetos .NET . Cada funcionalidade foi projetada para melhorar a flexibilidade e a eficiência dos seus esforços de automação de testes.

Caso de Uso: Integrando o IronPDF com o Specflow C

Um caso de uso prático para combinar o IronPDF com o Specflow é validar o conteúdo e a formatação de um relatório em PDF gerado pelo seu aplicativo. Por exemplo, você pode testar automaticamente se um relatório contém os dados corretos, se está de acordo com o layout esperado e se é acessível dentro dos requisitos estipulados. Essa integração se mostra especialmente útil em cenários onde a documentação precisa, como faturas ou relatórios de conformidade, é crucial.

Certifique-se de ter instalado o IronPDF. Você pode instalá-lo usando o console do pacote NuGet :

Install-Package IronPdf

Exemplo de código do caso de uso

Aqui está um exemplo de código completo que demonstra como configurar uma definição de etapa do SpecFlow para testar o conteúdo de um PDF usando o IronPDF. Este exemplo pressupõe que você esteja testando um documento PDF gerado pelo seu aplicativo que deve conter um texto específico:

using IronPdf;
using TechTalk.SpecFlow;

[Binding]
public class PdfContentSteps
{
    private string? _pdfPath;
    private PdfDocument? _pdfDocument;

    [Given(@"a PDF file generated at '(.*)'")]
    public void GivenAPDFFileGeneratedAt(string pdfPath)
    {
        _pdfPath = pdfPath;
        _pdfDocument = new PdfDocument(_pdfPath);
    }

    [Then(@"the PDF should contain the text '(.*)'")]
    public void ThenThePDFShouldContainTheText(string expectedText)
    {
        // Extract text from the PDF and check if it contains the expected text
        var textContent = _pdfDocument.ExtractAllText();
        if (!textContent.Contains(expectedText))
        {
            throw new Exception("PDF content does not contain the expected text.");
        }
    }
}

using IronPdf;
using TechTalk.SpecFlow;

[Binding]
public class PdfContentSteps
{
    private string? _pdfPath;
    private PdfDocument? _pdfDocument;

    [Given(@"a PDF file generated at '(.*)'")]
    public void GivenAPDFFileGeneratedAt(string pdfPath)
    {
        _pdfPath = pdfPath;
        _pdfDocument = new PdfDocument(_pdfPath);
    }

    [Then(@"the PDF should contain the text '(.*)'")]
    public void ThenThePDFShouldContainTheText(string expectedText)
    {
        // Extract text from the PDF and check if it contains the expected text
        var textContent = _pdfDocument.ExtractAllText();
        if (!textContent.Contains(expectedText))
        {
            throw new Exception("PDF content does not contain the expected text.");
        }
    }
}

Imports IronPdf
Imports TechTalk.SpecFlow

<Binding>
Public Class PdfContentSteps
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: private string? _pdfPath;
	Private _pdfPath As String
	Private _pdfDocument? As PdfDocument

	<Given("a PDF file generated at '(.*)'")>
	Public Sub GivenAPDFFileGeneratedAt(ByVal pdfPath As String)
		_pdfPath = pdfPath
		_pdfDocument = New PdfDocument(_pdfPath)
	End Sub

	<[Then]("the PDF should contain the text '(.*)'")>
	Public Sub ThenThePDFShouldContainTheText(ByVal expectedText As String)
		' Extract text from the PDF and check if it contains the expected text
		Dim textContent = _pdfDocument.ExtractAllText()
		If Not textContent.Contains(expectedText) Then
			Throw New Exception("PDF content does not contain the expected text.")
		End If
	End Sub
End Class

Neste código, definimos uma etapa do SpecFlow que primeiro carrega um PDF de um caminho especificado e, em seguida, verifica se esse PDF contém o texto esperado. A classe IronPdf.PdfDocument é usada para carregar e manipular o arquivo PDF. Essa configuração permite integrar a validação de PDF aos seus testes automatizados, facilitando a detecção de erros.