Melhores Práticas do MSTest (MSTest 3.x/4.x)

Seu objetivo é me ajudar a escrever testes de unidade eficazes com MSTest moderno, usando APIs e melhores práticas atuais.

Configuração do Projeto

• Use um projeto de teste separado com a convenção de nomenclatura [ProjectName].Tests
• Referencie pacotes NuGet do MSTest 3.x+ (inclui analisadores)
• Considere usar MSTest.Sdk para configuração simplificada do projeto
• Execute testes com dotnet test

Estrutura da Classe de Teste

• Use o atributo [TestClass] para classes de teste
• Sela classes de teste por padrão para desempenho e clareza de design
• Use [TestMethod] para métodos de teste (prefira em relação a [DataTestMethod])
• Siga o padrão Arrange-Act-Assert (AAA)
• Nomeie testes usando o padrão MethodName_Scenario_ExpectedBehavior

[TestClass]
public sealed class CalculatorTests
{
    [TestMethod]
    public void Add_TwoPositiveNumbers_ReturnsSum()
    {
        // Arrange
        var calculator = new Calculator();

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

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

Ciclo de Vida do Teste

• Prefira construtores em relação a [TestInitialize] - habilita campos readonly e segue padrões C# padrão
• Use [TestCleanup] para limpeza que deve ser executada mesmo que o teste falhe
• Combine construtor com [TestInitialize] assíncrono quando for necessária configuração assíncrona

[TestClass]
public sealed class ServiceTests
{
    private readonly MyService _service;  // readonly enabled by constructor

    public ServiceTests()
    {
        _service = new MyService();
    }

    [TestInitialize]
    public async Task InitAsync()
    {
        // Use for async initialization only
        await _service.WarmupAsync();
    }

    [TestCleanup]
    public void Cleanup() => _service.Reset();
}

Ordem de Execução

1. Inicialização da Assembly - [AssemblyInitialize] (uma vez por assembly de teste)
2. Inicialização da Classe - [ClassInitialize] (uma vez por classe de teste)
3. Inicialização do Teste (para cada método de teste):
   1. Construtor
   2. Defina a propriedade TestContext
   3. [TestInitialize]
4. Execução do Teste - o método de teste é executado
5. Limpeza do Teste (para cada método de teste):
   1. [TestCleanup]
   2. DisposeAsync (se implementado)
   3. Dispose (se implementado)
6. Limpeza da Classe - [ClassCleanup] (uma vez por classe de teste)
7. Limpeza da Assembly - [AssemblyCleanup] (uma vez por assembly de teste)

APIs Modernas de Asserção

O MSTest fornece três classes de asserção: Assert, StringAssert e CollectionAssert.

Classe Assert - Asserções Principais

// Equality
Assert.AreEqual(expected, actual);
Assert.AreNotEqual(notExpected, actual);
Assert.AreSame(expectedObject, actualObject);      // Reference equality
Assert.AreNotSame(notExpectedObject, actualObject);

// Null checks
Assert.IsNull(value);
Assert.IsNotNull(value);

// Boolean
Assert.IsTrue(condition);
Assert.IsFalse(condition);

// Fail/Inconclusive
Assert.Fail("Test failed due to...");
Assert.Inconclusive("Test cannot be completed because...");

Teste de Exceções (Prefira em relação a [ExpectedException])

// Assert.Throws - matches TException or derived types
var ex = Assert.Throws<ArgumentException>(() => Method(null));
Assert.AreEqual("Value cannot be null.", ex.Message);

// Assert.ThrowsExactly - matches exact type only
var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Method());

// Async versions
var ex = await Assert.ThrowsAsync<HttpRequestException>(async () => await client.GetAsync(url));
var ex = await Assert.ThrowsExactlyAsync<InvalidOperationException>(async () => await Method());

Asserções de Coleção (Classe Assert)

Assert.Contains(expectedItem, collection);
Assert.DoesNotContain(unexpectedItem, collection);
Assert.ContainsSingle(collection);  // exactly one element
Assert.HasCount(5, collection);
Assert.IsEmpty(collection);
Assert.IsNotEmpty(collection);

Asserções de String (Classe Assert)

Assert.Contains("expected", actualString);
Assert.StartsWith("prefix", actualString);
Assert.EndsWith("suffix", actualString);
Assert.DoesNotStartWith("prefix", actualString);
Assert.DoesNotEndWith("suffix", actualString);
Assert.MatchesRegex(@"\d{3}-\d{4}", phoneNumber);
Assert.DoesNotMatchRegex(@"\d+", textOnly);

Asserções de Comparação

Assert.IsGreaterThan(lowerBound, actual);
Assert.IsGreaterThanOrEqualTo(lowerBound, actual);
Assert.IsLessThan(upperBound, actual);
Assert.IsLessThanOrEqualTo(upperBound, actual);

…