NUnit ou xUnit .NET Core (Como funciona para desenvolvedores)

Métodos de teste e classes de teste

NUnit e xUnit permitem que os desenvolvedores estruturem seus testes unitários e criem configurações de teste usando métodos e classes de teste. Um método de teste representa um teste real, enquanto uma classe de teste agrupa métodos de teste relacionados. Essa organização ajuda a manter o código de teste e a compreender a abrangência dos resultados dos testes para uma área de aplicação específica. Uma das características mais marcantes tanto do NUnit quanto do xUnit é que cada framework suporta a execução paralela de testes, aumentando a eficiência da execução dos mesmos.

Dispositivos de teste e configuração

Os ambientes de teste (test fixtures) no NUnit e no xUnit fornecem uma maneira de configurar o ambiente necessário para a automação de testes por meio de métodos de configuração e desmontagem. Isso inclui inicializar dados, criar objetos simulados e configurar o estado necessário para a execução dos testes. Os dispositivos de teste ajudam a escrever códigos de teste limpos e de fácil manutenção.

// C# example of a test fixture in NUnit
using NUnit.Framework;

namespace MyTests
{
    [TestFixture]
    public class ExampleTests
    {
        [SetUp]
        public void Setup()
        {
            // Code to set up test context
        }

        [Test]
        public void TestMethod1()
        {
            // Test code goes here
        }

        [TearDown]
        public void Cleanup()
        {
            // Code to clean up after tests
        }
    }
}

// C# example of a test fixture in NUnit
using NUnit.Framework;

namespace MyTests
{
    [TestFixture]
    public class ExampleTests
    {
        [SetUp]
        public void Setup()
        {
            // Code to set up test context
        }

        [Test]
        public void TestMethod1()
        {
            // Test code goes here
        }

        [TearDown]
        public void Cleanup()
        {
            // Code to clean up after tests
        }
    }
}

' C# example of a test fixture in NUnit
Imports NUnit.Framework

Namespace MyTests
	<TestFixture>
	Public Class ExampleTests
		<SetUp>
		Public Sub Setup()
			' Code to set up test context
		End Sub

		<Test>
		Public Sub TestMethod1()
			' Test code goes here
		End Sub

		<TearDown>
		Public Sub Cleanup()
			' Code to clean up after tests
		End Sub
	End Class
End Namespace

// C# example of a test fixture in xUnit
using Xunit;

namespace MyTests
{
    public class ExampleTests : IDisposable
    {
        public ExampleTests()
        {
            // Code to set up test context
        }

        [Fact]
        public void TestMethod1()
        {
            // Test code goes here
        }

        public void Dispose()
        {
            // Code to clean up after tests
        }
    }
}

// C# example of a test fixture in xUnit
using Xunit;

namespace MyTests
{
    public class ExampleTests : IDisposable
    {
        public ExampleTests()
        {
            // Code to set up test context
        }

        [Fact]
        public void TestMethod1()
        {
            // Test code goes here
        }

        public void Dispose()
        {
            // Code to clean up after tests
        }
    }
}

' C# example of a test fixture in xUnit
Imports Xunit

Namespace MyTests
	Public Class ExampleTests
		Implements IDisposable

		Public Sub New()
			' Code to set up test context
		End Sub

		<Fact>
		Public Sub TestMethod1()
			' Test code goes here
		End Sub

		Public Sub Dispose() Implements IDisposable.Dispose
			' Code to clean up after tests
		End Sub
	End Class
End Namespace

Testes orientados por dados

NUnit e xUnit oferecem suporte a testes orientados a dados, permitindo que os desenvolvedores executem o mesmo método de teste com diferentes valores de entrada. Essa abordagem testa de forma eficiente uma função com diversas entradas e suporta a execução paralela de testes, reduzindo a necessidade de escrever múltiplos casos de teste.

// C# example of data-driven tests in NUnit using TestCase attribute
using NUnit.Framework;

namespace MyTests
{
    public class DataDrivenTests
    {
        [Test]
        [TestCase(1, 2, 3)]
        [TestCase(2, 3, 5)]
        public void Add_SumsCorrectly(int a, int b, int expected)
        {
            Assert.AreEqual(expected, a + b);
        }
    }
}

// C# example of data-driven tests in NUnit using TestCase attribute
using NUnit.Framework;

namespace MyTests
{
    public class DataDrivenTests
    {
        [Test]
        [TestCase(1, 2, 3)]
        [TestCase(2, 3, 5)]
        public void Add_SumsCorrectly(int a, int b, int expected)
        {
            Assert.AreEqual(expected, a + b);
        }
    }
}

' C# example of data-driven tests in NUnit using TestCase attribute
Imports NUnit.Framework

Namespace MyTests
	Public Class DataDrivenTests
		<Test>
		<TestCase(1, 2, 3)>
		<TestCase(2, 3, 5)>
		Public Sub Add_SumsCorrectly(ByVal a As Integer, ByVal b As Integer, ByVal expected As Integer)
			Assert.AreEqual(expected, a + b)
		End Sub
	End Class
End Namespace

// C# example of data-driven tests in xUnit using InlineData attribute
using Xunit;

namespace MyTests
{
    public class DataDrivenTests
    {
        [Theory]
        [InlineData(1, 2, 3)]
        [InlineData(2, 3, 5)]
        public void Add_SumsCorrectly(int a, int b, int expected)
        {
            Assert.Equal(expected, a + b);
        }
    }
}

// C# example of data-driven tests in xUnit using InlineData attribute
using Xunit;

namespace MyTests
{
    public class DataDrivenTests
    {
        [Theory]
        [InlineData(1, 2, 3)]
        [InlineData(2, 3, 5)]
        public void Add_SumsCorrectly(int a, int b, int expected)
        {
            Assert.Equal(expected, a + b);
        }
    }
}

' C# example of data-driven tests in xUnit using InlineData attribute
Imports Xunit

Namespace MyTests
	Public Class DataDrivenTests
		<Theory>
		<InlineData(1, 2, 3)>
		<InlineData(2, 3, 5)>
		Public Sub Add_SumsCorrectly(ByVal a As Integer, ByVal b As Integer, ByVal expected As Integer)
			Assert.Equal(expected, a + b)
		End Sub
	End Class
End Namespace

Execução de testes em paralelo

A execução paralela de testes é um recurso suportado tanto pelo NUnit quanto pelo xUnit. Permite a execução simultânea de vários testes, reduzindo o tempo total necessário para a execução dos mesmos. Essa funcionalidade é particularmente benéfica em projetos de grande porte com extensos conjuntos de testes.