Compartilhar via

Atributos MSTest

  • Artigo

MSTest usa atributos customizados para identificar e customizar testes.

Para ajudar a fornecer uma visão geral mais clara da estrutura de testes, essa seção organiza os membros do namespace Microsoft.VisualStudio.TestTools.UnitTesting em grupos de funcionalidades relacionadas.

Observação

Os atributos, cujos nomes terminam com “Atributo”, podem ser utilizados com ou sem “Atributo” no final. Atributos que possuem construtor sem parâmetros podem ser escritos com ou sem parênteses. Os exemplos de código a seguir funcionam de forma idêntica:

[TestClass()]

[TestClassAttribute()]

[TestClass]

[TestClassAttribute]

Atributos usados para identificar classes de teste e métodos

Cada classe de teste deve ter o atributo TestClass e cada método de teste deve ter o atributo TestMethod.

TestClassAttribute

O atributo TestClass marca uma classe que contém testes e, opcionalmente, métodos de inicialização ou limpeza.

Esse atributo pode ser estendido para alterar ou estender o comportamento padrão.

Exemplo:

[TestClass]
public class MyTestClass
{
}

TestMethodAttribute

O atributo TestMethod é usado dentro de um TestClass para definir o método de teste real a ser executado.

O método deve ser um método de instância public definido como void, Task ou ValueTask (começando com MSTest v3.3). Opcionalmente, pode ser async mas não deve ser async void.

O método deve ter parâmetros zero, a menos que esteja marcado com o atributo DataRow, o atributo DynamicData ou um atributo semelhante que fornece dados de caso de teste para o método de teste.

Considere o seguinte exemplo de classe de teste:

[TestClass]
public class MyTestClass
{
    [TestMethod]
    public void TestMethod()
    {
    }
}

Atributos usados para teste controlado por dados

Use os elementos a seguir para configurar testes baseados em dados. Para obter mais informações, confira Criar um teste de unidade controlado por dados e Usar um arquivo de configuração para definir uma fonte de dados.

DataRowAttribute

O atributo DataRow permite que você execute o mesmo método de teste com várias entradas diferentes. Ele pode aparecer uma ou várias vezes em um método de teste. Ele deve ser combinado com o atributo TestMethod.

O número e os tipos de argumentos devem corresponder exatamente à assinatura do método de teste. Considere o exemplo a seguir de uma classe de teste válida demonstrando o uso DataRowAttribute com argumentos embutidos que se alinham aos parâmetros do método de teste:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, "message", true, 2.0)]
    public void TestMethod1(int i, string s, bool b, float f)
    {
        // Omitted for brevity.
    }

    [TestMethod]
    [DataRow(new string[] { "line1", "line2" })]
    public void TestMethod2(string[] lines)
    {
        // Omitted for brevity.
    }

    [TestMethod]
    [DataRow(null)]
    public void TestMethod3(object o)
    {
        // Omitted for brevity.
    }

    [TestMethod]
    [DataRow(new string[] { "line1", "line2" }, new string[] { "line1.", "line2." })]
    public void TestMethod4(string[] input, string[] expectedOutput)
    {
        // Omitted for brevity.
    }
}

Observação

Você também pode usar o recurso params para capturar múltiplas entradas do DataRowAttribute.

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2, 3, 4)]
    public void TestMethod(params int[] values) {}
}

Exemplos de combinações inválidas:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2)] // Not valid, we are passing 2 inline data but signature expects 1
    public void TestMethod1(int i) {}

    [TestMethod]
    [DataRow(1)] // Not valid, we are passing 1 inline data but signature expects 2
    public void TestMethod2(int i, int j) {}

    [TestMethod]
    [DataRow(1)] // Not valid, count matches but types do not match
    public void TestMethod3(string s) {}
}

Observação

A partir do MSTest v3, quando você deseja passar exatamente duas matrizes, não é mais necessário encapsular a segunda matriz em uma matriz de objetos. Antes:[DataRow(new string[] { "a" }, new object[] { new string[] { "b" } })]Começando com v3:[DataRow(new string[] { "a" }, new string[] { "b" })]

Você pode modificar o nome de exibição usado no Visual Studio e os agentes para cada instância do DataRowAttribute definindo a propriedade DisplayName.

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2, DisplayName = "Functional Case FC100.1")]
    public void TestMethod(int i, int j) {}
}

Você também pode criar seu próprio atributo DataRow especializado herdando o DataRowAttribute.

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class MyCustomDataRowAttribute : DataRowAttribute
{
}

[TestClass]
public class TestClass
{
    [TestMethod]
    [MyCustomDataRow(1)]
    public void TestMethod(int i) {}
}

Atributos usados para fornecer inicialização e limpezas

A configuração e a limpeza comuns a vários testes podem ser extraídas para um método separado e marcadas com um dos atributos listados abaixo, para executá-lo no momento apropriado, por exemplo, antes de cada teste. Para obter mais informações, confira Anatomia de um teste de unidade.

Nível de assembly

O atributo AssemblyInitialize é chamado logo após o assembly ser carregado e o atributo AssemblyCleanup é chamado logo antes do seu assembly ser descarregado.

Os métodos marcados com esses atributos devem ser definidos como static void, static Task ou static ValueTask (começando com MSTest v3.3), em uma classe marcada com TestClassAttributee aparecem apenas uma vez. A inicialização requer um parâmetro de tipo TestContext, e a limpeza, ou sem parâmetros, ou a partir do MSTest 3.8, pode ter um parâmetro do tipo TestContext.

[TestClass]
public class MyTestClass
{
    [AssemblyInitialize]
    public static void AssemblyInitialize(TestContext testContext)
    {
    }

    [AssemblyCleanup]
    public static void AssemblyCleanup() // Starting with MSTest 3.8, it can be AssemblyCleanup(TestContext testContext)
    {
    }
}

Nível de classe

O atributo ClassInitialize é chamado logo antes de sua classe ser carregada (mas após o construtor estático) e o classCleanup é chamado logo após a sua classe ser descarregada.

Importante

Por padrão, ClassCleanupAttribute será acionado após o último teste do conjunto (da mesma forma que AssemblyCleanupAttribute). Você pode alterar esse comportamento definindo o CleanupBehavior no atributo. Como alternativa, você pode definir esse comportamento globalmente para o assembly usando o atributo assembly ClassCleanupExecutionAttribute.

Também é possível controlar o comportamento da herança: somente para a classe atual usando InheritanceBehavior.Noneou para todas as classes derivadas usando InheritanceBehavior.BeforeEachDerivedClass.

Os métodos marcados com esses atributos devem ser definidos como static void, static Task ou static ValueTask (a partir do MSTest v3.3), em um TestClass, e aparecer apenas uma vez. A inicialização requer um parâmetro do tipo TestContext, e a limpeza não requer parâmetros, ou, a partir do MSTest 3.8, pode ter um parâmetro do tipo TestContext.

[TestClass]
public class MyTestClass
{
    [ClassInitialize]
    public static void ClassInitialize(TestContext testContext)
    {
    }

    [ClassCleanup]
    public static void ClassCleanup() // Starting with MSTest 3.8, it can be ClassCleanup(TestContext testContext)
    {
    }
}

Nível de teste

O atributo TestInitialize é chamado logo antes do teste ser iniciado e o testCleanup é chamado logo após a conclusão do teste.

O TestInitializeAttribute é semelhante ao construtor de classe, mas geralmente é mais adequado para inicializações longas ou assíncronas. O TestInitializeAttribute é sempre chamado após o construtor e chamado para cada teste (incluindo cada entrada de testes controlados por dados).

O TestCleanupAttribute é semelhante à classe Dispose (ou DisposeAsync), mas geralmente é mais adequado para limpezas longas ou assíncronas. O TestCleanupAttribute é sempre chamado pouco antes do DisposeAsync/Dispose e chamado para cada teste (incluindo cada entrada de testes controlados por dados).

Os métodos marcados com esses atributos devem ser definidos como void, Task ou ValueTask (a partir do MSTest v3.3), em um TestClass, não ter parâmetros e aparecer uma ou várias vezes.

[TestClass]
public class MyTestClass
{
    [TestInitialize]
    public void TestInitialize()
    {
    }

    [TestCleanup]
    public void TestCleanup()
    {
    }
}

Atributos usados ​​para controlar a execução do teste

Os atributos a seguir podem ser usados ​​para modificar a forma como os testes são executados.

TimeoutAttribute

O atributo Timeout pode ser usado para especificar o tempo máximo em milissegundos que um método de teste pode ser executado. Se o método de teste durar mais do que o tempo especificado, o teste será abortado e marcado como reprovado.

Esse atributo pode ser aplicado a qualquer método de teste ou método de fixação (métodos de inicialização e limpeza). Também é possível especificar o tempo limite globalmente para todos os métodos de teste ou todos os métodos de fixação de teste usando as propriedades timeout do arquivo runsettings.

Observação

Não há garantia de que o tempo limite seja preciso. O teste será interrompido depois que o tempo especificado tiver passado, mas pode levar mais tempo até que a etapa seja cancelada.

Ao usar o recurso de tempo limite, um thread/tarefa separado é criado para executar o método de teste. O thread/tarefa principal é responsável por monitorar o tempo limite e desobservar o thread/tarefa do método se o tempo limite for atingido.

A partir do MSTest 3.6, é possível especificar a propriedade CooperativeCancellation no atributo (ou globalmente por meio de runsettings) para permitir o cancelamento cooperativo. Nesse modo, o método é responsável por verificar o token de cancelamento e abortar o teste caso ele seja sinalizado como faria em um método async típico. Esse modo tem melhor desempenho e permite um controle mais preciso sobre o processo de cancelamento. Esse modo pode ser aplicado a métodos assíncronos e sincronizados.

STATestClassAttribute

Quando aplicado a uma classe de teste, o atributo STATestClass indica que todos os métodos de teste (e os métodos [ClassInitialize] e [ClassCleanup]) na classe devem ser executados em um apartamento de thread único (STA). Esse atributo é útil quando os métodos de teste interagem com objetos COM que requerem STA.

Observação

Isso só tem suporte no Windows e na versão 3.6 e posterior.

STATestMethodAttribute

Quando aplicado a um método de teste, o atributo STATestMethod indica que o método de teste deve ser executado em um apartamento de thread único (STA). Esse atributo é útil quando o método de teste interage com objetos COM que requerem STA.

Observação

Isso só tem suporte no Windows e na versão 3.6 e posterior.

ParallelizeAttribute

Por padrão, o MSTest executa testes em ordem sequencial. O atributo de nível de assembly Parallelize pode ser usado para executar testes em paralelo. Você pode especificar se o paralelismo deve ser no nível da classe (múltiplas classes podem ser executadas em paralelo, mas os testes em uma determinada classe são executados sequencialmente) ou no nível do método.

Também é possível especificar o número máximo de threads a serem usados ​​para execução paralela. Um valor 0 (valor padrão) significa que o número de threads é igual ao número de processadores lógicos na máquina.

Também é possível especificar o paralelismo através das propriedades de paralelização do arquivo runsettings.

DoNotParallelizeAttribute

O atributo DoNotParallelize pode ser usado para evitar a execução paralela de testes em um determinado assembly. Esse atributo pode ser aplicado no nível do assembly, no nível da classe ou no nível do método.

Observação

Por padrão, o MSTest executa testes em ordem sequencial, portanto, você só precisará usar esse atributo se tiver aplicado o atributo Parallelize no nível do assembly.

RetryAttribute

O atributo Retry foi introduzido no MSTest 3.8. Esse atributo faz com que o método de teste seja executado novamente quando ele falhar ou atingir o tempo limite. Ele permite que você especifique o número máximo de tentativas de nova tentativa, o intervalo de tempo entre elas e um tipo de recuo de atraso, que pode ser constante ou exponencial.

Espera-se que apenas um RetryAttribute esteja presente em um método de teste e RetryAttribute não pode ser usado em métodos que não estão marcados com TestMethod.

Observação

RetryAttribute deriva de um RetryBaseAttribute abstrato. Você também pode criar suas próprias implementações de repetição se o RetryAttribute embutido não atender às suas necessidades.

Atributos de utilitários

DeploymentItemAttribute

O atributo DeploymentItem é usado para copiar arquivos ou pastas especificadas como itens de implantação para o diretório de implantação (sem adicionar um caminho de saída personalizado, os arquivos copiados estarão em TestResults pasta dentro da pasta do projeto). O diretório de implantação é onde todos os itens de implantação estão presentes junto com a DLL do projeto de teste.

Ele pode ser usado em classes de teste (classes marcadas com o atributo TestClass) ou em métodos de teste (métodos marcados com o atributo TestMethod).

Os usuários podem ter várias instâncias do atributo para especificar mais de um item.

E aqui você pode ver seus construtores.

Exemplo

[TestClass]
[DeploymentItem(@"C:\classLevelDepItem.xml")]   // Copy file using some absolute path
public class UnitTest1
{
    [TestMethod]
    [DeploymentItem(@"..\..\methodLevelDepItem1.xml")]   // Copy file using a relative path from the dll output location
    [DeploymentItem(@"C:\DataFiles\methodLevelDepItem2.xml", "SampleDataFiles")]   // File will be added under a SampleDataFiles in the deployment directory
    public void TestMethod1()
    {
        string textFromFile = File.ReadAllText("classLevelDepItem.xml");
    }
}

Aviso

Não recomendamos o uso desse atributo para copiar arquivos para o diretório de implantação.

ExpectedExceptionAttribute

O atributo ExpectedException define a exceção que o método de teste deve gerar. O teste será aprovado se a exceção esperada for lançada e a mensagem de exceção corresponder à mensagem esperada.

Aviso

Esse atributo existe para compatibilidade com versões anteriores e não é recomendado para novos testes. Em vez disso, use o método Assert.ThrowsException (ou Assert.ThrowsExactly se estiver usando o MSTest 3.8 e posterior).

Atributos de metadados

Os seguintes atributos e os valores atribuídos a eles aparecem na janela Visual StudioPropriedades para um método de teste específico. Esses atributos não devem ser acessados ​​por meio do código do teste. Em vez disso, eles afetam a forma como o teste é usado ou executado, por você por meio do IDE do Visual Studio ou pelo mecanismo de teste do Visual Studio. Por exemplo, alguns desses atributos aparecem como colunas nas janelas Gerenciador de Testes e Resultados do Teste, o que significa que é possível usá-las para agrupar e classificar testes e resultados de teste. Um desses atributos é TestPropertyAttribute, que você usa para adicionar metadados arbitrários aos testes.

Por exemplo, você pode usá-lo para armazenar o nome de uma "aprovação no teste" que esse teste abrange, marcando o teste com [TestProperty("Feature", "Accessibility")]. Como alternativa, você pode usá-lo para armazenar um indicador de que o tipo de teste é com o [TestProperty("ProductMilestone", "42")]. A propriedade criada por você com esse atributo e o valor da propriedade atribuído são exibidos na janela Propriedades do Visual Studio sob o título Especificidades do teste.

Os atributos abaixo relacionam o método de teste que eles decoram às entidades na hierarquia de projetos de um Team Foundation Server projeto de equipe: