Posso configurare NUnit in modo che Debug.Fail non mostri una finestra di messaggio quando eseguo i miei test?

Question

Ho quest'affare:

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; 
      } 
     } 
    } 

e questo test di unità

[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);    
    } 

C'è un modo per evitare che Debug.Fail la visualizzazione di una finestra di messaggio quando eseguo il mio test, ma permetto per mostrare me uno quando eseguo il debug dell'applicazione?

Answer 1

Il metodo standard che ho sempre fatto è quello di creare un plugin per NUnit. Il plug-in semplicemente annulla la registrazione del listener di trace predefinito e registra una sostituzione che genera un'eccezione quando viene attivato Assert/Trace.Fail. Mi piace questo approccio perché i test continueranno a fallire se un assert salta, non si aprono finestre di messaggio e non è necessario modificare il codice di produzione.

Modifica: ecco il codice del plugin nella sua interezza. Sei sul proprio per costruire il plugin vero però - controllare il sito 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

Invece di chiamare Debug.Assert direttamente, è possibile chiamare un metodo wrapper che controlla se un debugger è collegato prima di richiamare Debug.Assert. (Presumibilmente, esso dovrebbe generare un'eccezione se non v'è alcun debugger in modo che i test verranno a mancare.) Ad es .:

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

Answer 3

Un modo alternativo che non richiede cambiare il vostro codice di produzione o la scrittura di un costume NUnit aggiuntivo, sarebbe per sostituire gli ascoltatori di tracce in un dispositivo di installazione.

E.g. Aggiungi la classe seguente all'interno del namespace in cui si trovano i tuoi test:

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); 
     } 
    } 
}