Ncrunch todos os testes passam na primeira execução, mas falham após a alteração do código e quando todos os botões de execução são pressionados

Question

Estou executando o ncrunch, em uma nova solução MVC 4 no VS2012 usando nunit e ninject.

Quando abro a solução pela primeira vez, todos os cerca de 50 testes são executados e aprovados com êxito.

Depois de fazer qualquer alteração no código (mesmo apenas um espaço vazio adicionado), o ncrunch relata que a maior parte do meu teste de unidade falhou.A mesma coisa acontece se eu pressionar 'executar todos os testes' na janela do ncrunch.

Mas se você clicar no botão 'Executar todos os testes visíveis aqui', todos os 50 testes serão aprovados novamente e o ncrunch relatará que está tudo bem.

Além disso, quando você executa cada teste individualmente, eles passam sempre.

Quando eles falham, parecem estar falhando no meu código de configuração do ninject

Erro:TestFixtureSetUp falhou em ControllerTestSetup

public class ControllerTestSetup
{

    [SetUp]
    public void InitIntegrationTest()
    {
        var context = IntegrationTestContext.Instance;
        context.Init();
        context.NinjectKernel.Load<MediGapWebTestModule>();
    }

    [TearDown]
    public void DisposeIntegrationTest()
    {
        IntegrationTestContext.Instance.Dispose();
    }
}

public class IntegrationTestContext : IDisposable
{  

    private static IntegrationTestContext _instance = null;
    private static readonly object _monitor = new object();

    private IntegrationTestContext() { }

    public static IntegrationTestContext Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_monitor)
                {
                    if (_instance == null)
                    {
                        _instance = new IntegrationTestContext();
                    }
                }
            }

            return _instance;
        }
    }
}

Todos os testes também são executados no executor de testes do resharper sem problemas todas as vezes.

Alguem sabe o que poderia estar causando isso?

Suponho que tenha algo a ver com o código de bloqueio singleton dentro da propriedade Instance, mas não tenho certeza.

=================================================== ============================= Progresso:

Consegui rastrear isso até um erro no método de configuração do ninject acima, envolvendo-o em uma instrução try catch e gravando o erro na janela de saída.

A exceção foi causada pela tentativa de carregar um módulo mais de uma vez, mesmo que eu definitivamente não tenha feito isso e não use nenhum tipo de carregamento automático de módulo.

Isso acontece nas linhas

LocalSessionFactoryModule.SetMappingAssemblies(() => new[] { typeof(ProviderMap).Assembly });

_kernel.Load<LocalSessionFactoryModule>();
_sessionFactory = _kernel.Get<ISessionFactory>();

onde LocalSessionFactoryModule é a classe do módulo ninject derivada da classe NinjectModule.

Por que isso só acontece com o ncrunch e o que posso fazer para resolver esse problema?Existe uma maneira de verificar se um módulo já foi carregado?

Answer 1

O NCrunch nunca executará testes simultâneos dentro do mesmo processo, portanto, a menos que você tenha um comportamento multithread dentro de sua lógica de teste, deve ser seguro dizer que isso não é um problema causado pelo bloqueio ou threading no singleton.

Como você já tentou desabilitar a execução paralela e isso não fez diferença, presumo que o problema não seria causado pelo uso simultâneo de recursos fora do processo do executor de teste (ou seja,arquivos no disco).

Isso significa que o problema quase certamente está relacionado à sequência em que os testes estão sendo executados.Quase todos os executores de testes manuais (incluindo o Resharper) executarão testes em uma sequência definida do início ao fim.Isso é bom para a consistência, mas pode mascarar problemas que podem surgir quando os testes são executados em uma ordem inconsistente/aleatória.O NCrunch executará testes em ordem de prioridade e também poderá reutilizar processos de teste entre execuções de teste, o que pode tornar o comportamento de tempo de execução de seus testes diferente se eles não tiverem sido projetados com isso em mente.

Uma maneira útil de revelar (e, portanto, depurar) problemas relacionados à sequência é tentar executar seus testes em uma ordem definida manualmente usando NCrunch.Se você clicar com o botão direito em um teste dentro da janela de testes do NCrunch, no menu 'Avançado' você encontrará uma opção para executar um teste usando um processo executor de tarefas existente.Experimente esta ação em vários de seus testes para ver se você consegue reproduzir a sequência que revela o problema.Quando isso acontecer, você poderá facilmente colocar um depurador no teste e descobrir por que ele está falhando.

A maioria dos problemas relacionados à sequência são causados ​​por membros estáticos não limpos, portanto, certifique-se de que cada um dos seus testes seja escrito assumindo que o estado existente pode ser deixado para trás por outro teste que foi executado dentro do processo.Outra opção é garantir que todo o estado seja totalmente limpo por meio de testes de desmontagem (embora, na minha opinião, esta seja frequentemente uma abordagem menos pragmática).