Execute testes de unidade em série (em vez de em paralelo)

Estou tentando fazer o teste de unidade de um mecanismo de gerenciamento de host WCF que escrevi. O mecanismo basicamente cria instâncias ServiceHost dinamicamente com base na configuração. Isso nos permite reconfigurar dinamicamente quais serviços estão disponíveis sem ter que desativá-los e reiniciá-los sempre que um novo serviço for adicionado ou um antigo removido.

No entanto, tive dificuldade em testar a unidade deste mecanismo de gerenciamento de host devido à maneira como o ServiceHost funciona. Se um ServiceHost já tiver sido criado, aberto e ainda não fechado para um ponto de extremidade específico, outro ServiceHost para o mesmo ponto de extremidade não pode ser criado, resultando em uma exceção. Por causa do fato de que as plataformas de teste de unidade modernas paralelizam sua execução de teste, não tenho uma maneira eficaz de testar essa parte do código.

Usei o xUnit.NET, esperando que, devido à sua extensibilidade, pudesse encontrar uma maneira de forçá-lo a executar os testes em série. No entanto, não tive sorte. Espero que alguém aqui no SO tenha encontrado um problema semelhante e saiba como fazer com que os testes de unidade sejam executados em série.

NOTA: ServiceHost é uma classe WCF, escrita pela Microsoft. Não tenho capacidade de mudar seu comportamento. Hospedar cada ponto de extremidade de serviço apenas uma vez também é o comportamento adequado ... entretanto, não é particularmente adequado para testes de unidade.

Cada classe de teste é uma coleção de teste exclusiva e os testes sob ela serão executados em sequência, portanto, se você colocar todos os seus testes na mesma coleção, ela será executada sequencialmente.

No xUnit, você pode fazer as seguintes alterações para conseguir isso:

O seguinte será executado em paralelo:

namespace IntegrationTests
{
    public class Class1
    {
        [Fact]
        public void Test1()
        {
            Console.WriteLine("Test1 called");
        }

        [Fact]
        public void Test2()
        {
            Console.WriteLine("Test2 called");
        }
    }

    public class Class2
    {
        [Fact]
        public void Test3()
        {
            Console.WriteLine("Test3 called");
        }

        [Fact]
        public void Test4()
        {
            Console.WriteLine("Test4 called");
        }
    }
}

Para torná-lo sequencial, você só precisa colocar as duas classes de teste na mesma coleção:

namespace IntegrationTests
{
    [Collection("Sequential")]
    public class Class1
    {
        [Fact]
        public void Test1()
        {
            Console.WriteLine("Test1 called");
        }

        [Fact]
        public void Test2()
        {
            Console.WriteLine("Test2 called");
        }
    }

    [Collection("Sequential")]
    public class Class2
    {
        [Fact]
        public void Test3()
        {
            Console.WriteLine("Test3 called");
        }

        [Fact]
        public void Test4()
        {
            Console.WriteLine("Test4 called");
        }
    }
}

Para mais informações, você pode consultar este link

Conforme declarado acima, todos os bons testes de unidade devem ser 100% isolados. Usar o estado compartilhado (por exemplo, dependendo de uma staticpropriedade que é modificada por cada teste) é considerado uma prática ruim.

Dito isso, sua pergunta sobre a execução de testes xUnit em sequência tem uma resposta! Eu encontrei exatamente o mesmo problema porque meu sistema usa um localizador de serviço estático (que é menos do que ideal).

Por padrão, o xUnit 2.x executa todos os testes em paralelo. Isso pode ser modificado por assembly, definindo CollectionBehaviorem seu AssemblyInfo.cs em seu projeto de teste.

Para separação por montagem, use:

using Xunit;
[assembly: CollectionBehavior(CollectionBehavior.CollectionPerAssembly)]

ou para nenhuma paralelização, use:

[assembly: CollectionBehavior(DisableTestParallelization = true)]

Este é provavelmente o que você deseja. Mais informações sobre paralelização e configuração podem ser encontradas na documentação do xUnit .

Para projetos .NET Core, crie xunit.runner.jsoncom:

{
  "parallelizeAssembly": false,
  "parallelizeTestCollections": false
}

Além disso, você csprojdeve conter

<ItemGroup>
  <None Update="xunit.runner.json"> 
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </None>
</ItemGroup>

Para projetos antigos .Net Core, o seu project.jsondeve conter

"buildOptions": {
  "copyToOutput": {
    "include": [ "xunit.runner.json" ]
  }
}

Para projetos .NET Core, você pode configurar o xUnit com um xunit.runner.jsonarquivo, conforme documentado em https://xunit.github.io/docs/configuring-with-json.html .

A configuração que você precisa alterar para interromper a execução do teste paralelo é parallelizeTestCollections, cujo padrão é true:

Defina como truese o assembly estiver disposto a executar testes dentro desse assembly em paralelo uns com os outros. ... Defina como falsepara desativar toda a paralelização neste conjunto de teste.

Tipo de esquema JSON: booleano
Valor padrão:true

Portanto, um mínimo xunit.runner.jsonpara esta finalidade parece

{
    "parallelizeTestCollections": false
}

Conforme observado nos documentos, lembre-se de incluir este arquivo em sua compilação:

• Configurando Copiar para Diretório de Saída para Copiar se for mais recente nas Propriedades do arquivo no Visual Studio, ou

• Adicionando

  <Content Include=".\xunit.runner.json">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </Content>

  para o seu .csprojarquivo, ou

• Adicionando

  "buildOptions": {
    "copyToOutput": {
      "include": [ "xunit.runner.json" ]
    }
  }

  para o seu project.jsonarquivo

dependendo do seu tipo de projeto.

Finalmente, além do acima, se você estiver usando o Visual Studio, certifique-se de não clicar acidentalmente no botão Executar testes em paralelo , o que fará com que os testes sejam executados em paralelo, mesmo se você tiver desativado a paralelização em xunit.runner.json. Os designers de IU da Microsoft habilmente tornaram esse botão sem rótulo, difícil de notar e a cerca de um centímetro de distância do botão "Executar tudo" no Test Explorer, apenas para maximizar a chance de você acertá-lo por engano e não ter ideia de por que seus testes estão falhando de repente:

Esta é uma questão antiga, mas eu queria escrever uma solução para as pessoas que pesquisam recentemente como eu :)

Nota: Eu uso este método em testes de integração Dot Net Core WebUI com xunit versão 2.4.1.

Crie uma classe vazia denominada NonParallelCollectionDefinitionClass e, a seguir, atribua o atributo CollectionDefinition a essa classe conforme abaixo. (A parte importante é DisableParallelization = true setting.)

using Xunit;

namespace WebUI.IntegrationTests.Common
{
    [CollectionDefinition("Non-Parallel Collection", DisableParallelization = true)]
    public class NonParallelCollectionDefinitionClass
    {
    }
}

Depois, adicione o atributo Collection à classe que você não deseja que execute em paralelo, como abaixo. (A parte importante é o nome da coleção. Deve ser o mesmo nome usado em CollectionDefinition)

namespace WebUI.IntegrationTests.Controllers.Users
{
    [Collection("Non-Parallel Collection")]
    public class ChangePassword : IClassFixture<CustomWebApplicationFactory<Startup>>
    ...

Quando fazemos isso, primeiro são executados outros testes paralelos. Depois disso, os outros testes que possuem o atributo Collection ("Non-Parallel Collection") são executados.

você pode usar a lista de reprodução

clique com o botão direito no método de teste -> Adicionar à lista de reprodução -> Nova lista de reprodução

então você pode especificar a ordem de execução, o padrão é, conforme você os adiciona à lista de reprodução, mas você pode alterar o arquivo da lista de reprodução como quiser

Não sei os detalhes, mas parece que você está tentando fazer um teste de integração em vez de um teste de unidade . Se você pudesse isolar a dependência de ServiceHost, isso provavelmente tornaria seus testes mais fáceis (e rápidos). Então (por exemplo) você pode testar o seguinte independentemente:

• Aula de leitura de configuração
• Fábrica de ServiceHost (possivelmente como um teste de integração)
• Classe de motor que leva um IServiceHostFactorye umIConfiguration

Ferramentas que ajudariam a incluir estruturas de isolamento (simulação) e (opcionalmente) estruturas de contêiner IoC. Vejo:

• http://www.mockobjects.com/
• http://www.hanselman.com/blog/ListOfNETDependencyInjectionContainersIOC.aspx

Talvez você possa usar o Teste de Unidade Avançado . Ele permite que você defina a sequência em que você executa o teste . Portanto, pode ser necessário criar um novo arquivo cs para hospedar esses testes.

Veja como você pode dobrar os métodos de teste para funcionarem na sequência desejada.

[Test]
[Sequence(16)]
[Requires("POConstructor")]
[Requires("WorkOrderConstructor")]
public void ClosePO()
{
  po.Close();

  // one charge slip should be added to both work orders

  Assertion.Assert(wo1.ChargeSlipCount==1,
    "First work order: ChargeSlipCount not 1.");
  Assertion.Assert(wo2.ChargeSlipCount==1,
    "Second work order: ChargeSlipCount not 1.");
  ...
}

Deixe-me saber se funciona.

Para mim, no aplicativo .Net Core Console, quando eu queria executar métodos de teste (não classes) de forma síncrona, a única solução que funcionou foi esta descrita neste blog: xUnit: Controlar a ordem de execução do teste

Eu adicionei o atributo [Collection ("Sequential")] em uma classe base:

    namespace IntegrationTests
    {
      [Collection("Sequential")]
      public class SequentialTest : IDisposable
      ...


      public class TestClass1 : SequentialTest
      {
      ...
      }

      public class TestClass2 : SequentialTest
      {
      ...
      }
    }

Nenhuma das respostas sugeridas até agora funcionou para mim. Eu tenho um aplicativo dotnet core com XUnit 2.4.1. Alcancei o comportamento desejado com uma solução alternativa, colocando um bloqueio em cada teste de unidade. No meu caso, não me importei com a ordem de execução, apenas que os testes eram sequenciais.

public class TestClass
{
    [Fact]
    void Test1()
    {
        lock (this)
        {
            //Test Code
        }
    }

    [Fact]
    void Test2()
    {
        lock (this)
        {
            //Test Code
        }
    }
}