¿Puedo configurar NUnit para que Debug.Fail no muestre un cuadro de mensaje cuando ejecuto mis pruebas?

Question

tengo esta propiedad:

public SubjectStatus Status 
    { 
     get { return status; } 
     set 
     { 
      if (Enum.IsDefined(typeof(SubjectStatus), value)) 
      { 
       status = value; 
      } 
      else 
      { 
       Debug.Fail("Error setting Subject.Status", "There is no SubjectStatus enum constant defined for that value."); 
       return; 
      } 
     } 
    } 

y esto prueba de la unidad

[Test] 
    public void StatusProperty_StatusAssignedValueWithoutEnumDefinition_StatusUnchanged() 
    { 
     Subject subject = new TestSubjectImp("1"); 

     // assigned by casting from an int to a defined value 
     subject.Status = (SubjectStatus)2; 
     Assert.AreEqual(SubjectStatus.Completed, subject.Status);    

     // assigned by casting from an int to an undefined value 
     subject.Status = (SubjectStatus)100; 
     // no change to previous value 
     Assert.AreEqual(SubjectStatus.Completed, subject.Status);    
    } 

¿Hay alguna manera de evitar que Debug.Fail mostrar un cuadro de mensaje cuando corro mis pruebas, pero permitir que se muestre ¿uno cuando depuro mi aplicación?

Answer 1

La manera estándar que siempre he hecho es crear un plugin para NUnit. El complemento simplemente anula el registro del escucha de seguimiento predeterminado y registra un reemplazo que arroja una excepción cuando se activa Assert/Trace.Fail. Me gusta este enfoque porque las pruebas seguirán fallando si se activa una afirmación, no aparece ningún cuadro de mensaje emergente y no tiene que modificar su código de producción.

Editar - aquí está el código del complemento en su totalidad. Usted está en su propia para construir el plugin real, aunque - comprobar el sitio NUnit :)

[NUnitAddin] 
public class NUnitAssertionHandler : IAddin 
{ 
    public bool Install(IExtensionHost host) 
    { 
     Debug.Listeners.Clear(); 
     Debug.Listeners.Add(new AssertFailTraceListener()); 
     return true; 
    } 

    private class AssertFailTraceListener : DefaultTraceListener 
    { 
     public override void Fail(string message, string detailMessage) 
     { 
      Assert.Fail("Assertion failure: " + message); 
     } 

     public override void Fail(string message) 
     { 
      Assert.Fail("Assertion failure: " + message); 
     } 
    } 
} 

Answer 2

En lugar de llamar a Debug.Assert directamente, puede llamar a un método de envoltura que comprueba si hay un depurador conectado antes de invocar a Debug.Assert. (Es de suponer que se debe lanzar una excepción si no hay un depurador asociado para que sus pruebas se producirá un error.) Ej .:

[Conditional("DEBUG")] 
public static void Assert(bool condition) 
{ 
    if (Debugger.IsAttached) 
    { 
     Debug.Assert(condition); 
    } 
    else 
    { 
     throw new SomeException(); 
    } 
} 

Answer 3

Una forma alternativa que no requiere cambiar su código de producción o escribir una costumbre NUnit complemento, sería para reemplazar los oyentes de seguimiento en un accesorio de configuración.

E.g. Agregue la siguiente clase dentro del espacio de nombres donde están sus pruebas:

using System; 
using System.Diagnostics; 
using NUnit.Framework; 

[SetUpFixture] 
public class NUnitSetup 
{ 
    // Field to hold exisitng trace listeners so they can be restored after test are run. 
    private TraceListener[] originalListeners = null; 

    // A trace listener to use during testing. 
    private TraceListener nunitListener = new NUnitListener(); 

    [SetUp] 
    public void SetUp() 
    { 
     // Replace existing listeners with listener for testing. 
     this.originalListeners = new TraceListener[Trace.Listeners.Count]; 
     Trace.Listeners.CopyTo(this.originalListeners, 0); 
     Trace.Listeners.Clear(); 
     Trace.Listeners.Add(this.nunitListener); 
    } 

    [TearDown] 
    public void TearDown() 
    { 
     // Restore original trace listeners. 
     Trace.Listeners.Remove(this.nunitListener); 
     Trace.Listeners.AddRange(this.originalListeners); 
    } 

    public class NUnitListener : DefaultTraceListener 
    { 
     public override void Fail(string message) 
     { 
      Console.WriteLine("Ignoring Debug.Fail(\"{0}\")", message); 
     } 

     public override void Fail(string message, string detailMessage) 
     { 
      Console.WriteLine("Ignoring Debug.Fail(\"{0},{1}\")", message, detailMessage); 
     } 
    } 
}