Determine se o código está sendo executado como parte de um teste de unidade

Eu tenho um teste de unidade (nUnit). Muitas camadas abaixo da pilha de chamadas, um método falhará se estiver sendo executado por meio de um teste de unidade.

Idealmente, você usaria algo como simulação para configurar o objeto do qual esse método depende, mas este é um código de terceiros e não posso fazer isso sem muito trabalho.

Não quero configurar métodos específicos do nUnit - há muitos níveis aqui e é uma maneira ruim de fazer o teste de unidade.

Em vez disso, o que eu gostaria de fazer é adicionar algo assim no fundo da pilha de chamadas

#IF DEBUG // Unit tests only included in debug build
if (IsRunningInUnitTest)
   {
   // Do some setup to avoid error
   }
#endif

Então, alguma ideia sobre como escrever IsRunningInUnitTest?

PS: Estou totalmente ciente de que este não é um ótimo design, mas acho que é melhor do que as alternativas.

Já fiz isso antes - tive que segurar meu nariz enquanto fazia, mas consegui. O pragmatismo vence o dogmatismo todas as vezes. Claro, se não é uma boa maneira você pode refatorar para evitá-lo, isso seria ótimo.

Basicamente, eu tinha uma classe "UnitTestDetector" que verificava se o assembly da estrutura NUnit foi carregado no AppDomain atual. Ele só precisava fazer isso uma vez e, em seguida, armazenar em cache o resultado. Feio, mas simples e eficaz.

Pegando a ideia de Jon, isso é o que eu tive -

using System;
using System.Reflection;

/// <summary>
/// Detect if we are running as part of a nUnit unit test.
/// This is DIRTY and should only be used if absolutely necessary 
/// as its usually a sign of bad design.
/// </summary>    
static class UnitTestDetector
{

    private static bool _runningFromNUnit = false;      

    static UnitTestDetector()
    {
        foreach (Assembly assem in AppDomain.CurrentDomain.GetAssemblies())
        {
            // Can't do something like this as it will load the nUnit assembly
            // if (assem == typeof(NUnit.Framework.Assert))

            if (assem.FullName.ToLowerInvariant().StartsWith("nunit.framework"))
            {
                _runningFromNUnit = true;
                break;
            }
        }
    }

    public static bool IsRunningFromNUnit
    {
        get { return _runningFromNUnit; }
    }
}

Pule na parte de trás, somos todos meninos grandes o suficiente para reconhecer quando estamos fazendo algo que provavelmente não deveríamos;)

Adaptado da resposta de Ryan. Este é para a estrutura de teste de unidade MS.

O motivo pelo qual preciso disso é porque mostro uma MessageBox sobre erros. Mas meus testes de unidade também testam o código de tratamento de erros, e não quero que uma MessageBox apareça durante a execução de testes de unidade.

/// <summary>
/// Detects if we are running inside a unit test.
/// </summary>
public static class UnitTestDetector
{
    static UnitTestDetector()
    {
        string testAssemblyName = "Microsoft.VisualStudio.QualityTools.UnitTestFramework";
        UnitTestDetector.IsInUnitTest = AppDomain.CurrentDomain.GetAssemblies()
            .Any(a => a.FullName.StartsWith(testAssemblyName));
    }

    public static bool IsInUnitTest { get; private set; }
}

E aqui está um teste de unidade para isso:

    [TestMethod]
    public void IsInUnitTest()
    {
        Assert.IsTrue(UnitTestDetector.IsInUnitTest, 
            "Should detect that we are running inside a unit test."); // lol
    }

Simplificando a solução de Ryan, você pode simplesmente adicionar a seguinte propriedade estática a qualquer classe:

    public static readonly bool IsRunningFromNUnit = 
        AppDomain.CurrentDomain.GetAssemblies().Any(
            a => a.FullName.ToLowerInvariant().StartsWith("nunit.framework"));

Eu uso uma abordagem semelhante ao Tallseth

Este é o código básico que pode ser facilmente modificado para incluir o cache. Outra boa ideia seria adicionar um setter IsRunningInUnitTeste chamar UnitTestDetector.IsRunningInUnitTest = falseo ponto de entrada principal do seu projeto para evitar a execução do código.

public static class UnitTestDetector
{
    public static readonly HashSet<string> UnitTestAttributes = new HashSet<string> 
    {
        "Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute",
        "NUnit.Framework.TestFixtureAttribute",
    };
    public static bool IsRunningInUnitTest
    {
        get
        {
            foreach (var f in new StackTrace().GetFrames())
                if (f.GetMethod().DeclaringType.GetCustomAttributes(false).Any(x => UnitTestAttributes.Contains(x.GetType().FullName)))
                    return true;
            return false;
        }
    }
}

Pode ser útil, verificar o ProcessName atual:

public static bool UnitTestMode
{
    get 
    { 
        string processName = System.Diagnostics.Process.GetCurrentProcess().ProcessName;

        return processName == "VSTestHost"
                || processName.StartsWith("vstest.executionengine") //it can be vstest.executionengine.x86 or vstest.executionengine.x86.clr20
                || processName.StartsWith("QTAgent");   //QTAgent32 or QTAgent32_35
    }
}

E esta função também deve ser verificada por teste de unidade:

[TestClass]
public class TestUnittestRunning
{
    [TestMethod]
    public void UnitTestRunningTest()
    {
        Assert.IsTrue(MyTools.UnitTestMode);
    }
}

Referências:
Matthew Watson em http://social.msdn.microsoft.com/Forums/en-US/csharplanguage/thread/11e68468-c95e-4c43-b02b-7045a52b407e/

Em modo de teste, Assembly.GetEntryAssembly()parece ser null.

#IF DEBUG // Unit tests only included in debug build 
  if (Assembly.GetEntryAssembly() == null)    
  {
    // Do some setup to avoid error    
  }
#endif 

Observe que se Assembly.GetEntryAssembly()é null, Assembly.GetExecutingAssembly()não é.

A documentação diz: O GetEntryAssemblymétodo pode retornar nullquando um assembly gerenciado foi carregado de um aplicativo não gerenciado.

Em algum lugar do projeto que está sendo testado:

public static class Startup
{
    public static bool IsRunningInUnitTest { get; set; }
}

Em algum lugar do seu projeto de teste de unidade:

[TestClass]
public static class AssemblyInitializer
{
    [AssemblyInitialize]
    public static void Initialize(TestContext context)
    {
        Startup.IsRunningInUnitTest = true;
    }
}

Elegante, não. Mas direto e rápido. AssemblyInitializeré para MS Test. Eu esperaria que outras estruturas de teste tivessem equivalentes.

Eu uso isso apenas para ignorar a lógica que desativa todos os TraceAppenders em log4net durante a inicialização quando nenhum depurador está conectado. Isso permite que os testes de unidade sejam registrados na janela de resultados do Resharper, mesmo quando executados no modo sem depuração.

O método que usa esta função é chamado na inicialização do aplicativo ou ao iniciar um dispositivo de teste.

É semelhante à postagem de Ryan, mas usa LINQ, elimina o requisito System.Reflection, não armazena em cache o resultado e é privado para evitar o uso incorreto (acidental).

    private static bool IsNUnitRunning()
    {
        return AppDomain.CurrentDomain.GetAssemblies().Any(assembly => assembly.FullName.ToLowerInvariant().StartsWith("nunit.framework"));
    }

Ter uma referência à estrutura nunit não significa que o teste está realmente em execução. Por exemplo, no Unity, quando você ativa os testes do modo de reprodução, as referências da nunidade são adicionadas ao projeto. E quando você executa um jogo, as referências existem, então UnitTestDetector não funcionaria corretamente.

Em vez de verificar o assembly do nunit, podemos pedir ao nunit api para verificar se o código está sendo executado no teste ou não.

using NUnit.Framework;

// ...

if (TestContext.CurrentContext != null)
{
    // nunit test detected
    // Do some setup to avoid error
}

Editar:

Esteja ciente de que o TestContext pode ser gerado automaticamente se for necessário.

Basta usar isto:

AppDomain.CurrentDomain.IsDefaultAppDomain()

No modo de teste, ele retornará falso.

Fiquei infeliz por ter esse problema recentemente. Eu resolvi isso de uma maneira um pouco diferente. Primeiro, eu não estava disposto a supor que o framework nunit nunca seria carregado fora de um ambiente de teste; Eu estava particularmente preocupado com os desenvolvedores executando o aplicativo em suas máquinas. Então, em vez disso, percorri a pilha de chamadas. Em segundo lugar, fui capaz de presumir que o código de teste nunca seria executado em binários de lançamento, portanto, certifiquei-me de que esse código não existisse em um sistema de lançamento.

internal abstract class TestModeDetector
{
    internal abstract bool RunningInUnitTest();

    internal static TestModeDetector GetInstance()
    {
    #if DEBUG
        return new DebugImplementation();
    #else
        return new ReleaseImplementation();
    #endif
    }

    private class ReleaseImplementation : TestModeDetector
    {
        internal override bool RunningInUnitTest()
        {
            return false;
        }
    }

    private class DebugImplementation : TestModeDetector
    {
        private Mode mode_;

        internal override bool RunningInUnitTest()
        {
            if (mode_ == Mode.Unknown)
            {
                mode_ = DetectMode();
            }

            return mode_ == Mode.Test;
        }

        private Mode DetectMode()
        {
            return HasUnitTestInStack(new StackTrace()) ? Mode.Test : Mode.Regular;
        }

        private static bool HasUnitTestInStack(StackTrace callStack)
        {
            return GetStackFrames(callStack).SelectMany(stackFrame => stackFrame.GetMethod().GetCustomAttributes(false)).Any(NunitAttribute);
        }

        private static IEnumerable<StackFrame> GetStackFrames(StackTrace callStack)
        {
            return callStack.GetFrames() ?? new StackFrame[0];
        }

        private static bool NunitAttribute(object attr)
        {
            var type = attr.GetType();
            if (type.FullName != null)
            {
                return type.FullName.StartsWith("nunit.framework", StringComparison.OrdinalIgnoreCase);
            }
            return false;
        }

        private enum Mode
        {
            Unknown,
            Test,
            Regular
        }

Funciona como um encanto

if (AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x => x.FullName.ToLowerInvariant().StartsWith("nunit.framework")) != null)
{
    fileName = @"C:\Users\blabla\xxx.txt";
}
else
{
    var sfd = new SaveFileDialog
    {     ...     };
    var dialogResult = sfd.ShowDialog();
    if (dialogResult != DialogResult.OK)
        return;
    fileName = sfd.FileName;
}

.

Os testes de unidade irão ignorar o ponto de entrada do aplicativo. Pelo menos para wpf, winforms e aplicativo de console main()não está sendo chamado.

Se o método principal for chamado, então estamos em tempo de execução , caso contrário, estamos no modo de teste de unidade :

public static bool IsUnitTest { get; private set; } = true;

[STAThread]
public static void main()
{
    IsUnitTest = false;
    ...
}

Considerando que seu código é normalmente executado no thread principal (gui) de um aplicativo do Windows Forms e você deseja que ele se comporte de forma diferente durante a execução de um teste, você pode verificar

if (SynchronizationContext.Current == null)
{
    // code running in a background thread or from within a unit test
    DoSomething();
}
else
{
    // code running in the main thread or any other thread where
    // a SynchronizationContext has been set with
    // SynchronizationContext.SetSynchronizationContext(synchronizationContext);
    DoSomethingAsync();
}

Estou usando isso para o código que desejo fire and forgot em um aplicativo gui, mas nos testes de unidade, posso precisar do resultado calculado para uma declaração e não quero mexer com vários threads em execução.

Funciona para MSTest. A vantagem é que meu código não precisa verificar a estrutura de teste em si e se eu realmente preciso do comportamento assíncrono em um determinado teste, posso definir meu próprio SynchronizationContext.

Esteja ciente de que este não é um método confiável para, Determine if code is running as part of a unit testconforme solicitado pelo OP, uma vez que o código pode estar sendo executado dentro de um thread, mas para certos cenários, esta pode ser uma boa solução (também: Se eu já estiver executando a partir de um thread de segundo plano, pode não ser necessário para iniciar um novo).

Application.Current é nulo quando executado no testador de unidade. Pelo menos para o meu aplicativo WPF usando o testador de unidade MS. É um teste fácil de fazer, se necessário. Além disso, algo para se ter em mente ao usar Application.Current em seu código.

Usei o seguinte em VB em meu código para verificar se estamos em um teste de unidade. especificamente, eu não queria que o teste abrisse o Word

    If Not Application.ProductName.ToLower().Contains("test") then
        ' Do something 
    End If

Que tal usar reflexão e algo assim:

var underTest = Assembly.GetCallingAssembly ()! = typeof (MainForm) .Assembly;

O assembly de chamada estará onde seus casos de teste estão e apenas substituirá o MainForm por algum tipo que está em seu código sendo testado.

Também há uma solução muito simples quando você está testando uma classe ...

Basta fornecer à classe que você está testando uma propriedade como esta:

// For testing purposes to avoid running certain code in unit tests.
public bool thisIsUnitTest { get; set; }

Agora seu teste de unidade pode definir o booleano "thisIsUnitTest" como verdadeiro, portanto, no código que você deseja pular, adicione:

   if (thisIsUnitTest)
   {
       return;
   } 

É mais fácil e rápido do que inspecionar as montagens. Lembra-me do Ruby On Rails, onde você olha para ver se está no ambiente de TESTE.