Czy mogę skonfigurować NUnit, aby Debug.Fail nie wyświetlał okna komunikatu po uruchomieniu testów?

Question

mam tę właściwość:

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

i ten test jednostki

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

Czy istnieje sposób mogę zapobiec Debug.Fail wyświetlając okno komunikatu, gdy uruchomię moich testów, ale pozwolić mu pokazać mnie, kiedy debuguję aplikację?

Answer 1

standardowy sposób zawsze zrobić to stworzyć plugin NUnit. Wtyczka po prostu wyrejestruje domyślny detektor śledzenia i zarejestruje zamiennik, który zgłasza wyjątek po uruchomieniu Assert/Trace.Fail. Podoba mi się to podejście, ponieważ testy nadal będą nieskuteczne, jeśli wystąpią awarie, nie pojawi się żaden komunikat i nie trzeba modyfikować kodu produkcyjnego.

Edytuj - oto kod wtyczki w całości. Jesteś na własną rękę do budowania rzeczywistego wtyczki chociaż - sprawdź witrynę 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

Zamiast wywoływać Debug.Assert bezpośrednio, można wywołać metodę wrapper, która sprawdza, czy debugger jest dołączony przed wywołaniem Debug.Assert. (Można przypuszczać, że powinna ona wyjątek, jeśli nie ma debugger przymocowany tak, że testy nie powiedzie się.) Np .:

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

Answer 3

Alternatywny sposób, który nie wymaga wymiany kod produkcyjny lub pisząc zwyczaj NUnit dodatek byłby aby zastąpić detektory śledzenia w urządzeniu konfiguracyjnym.

E.g. Dodaj następującą klasę w przestrzeni nazw, w której znajdują się twoje testy:

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