Wie Unit Test Dispose() mit Reflektion?

Question

Ich möchte Komponententests für eine Klasse schreiben, die IDisposable implementiert. Die Klasse verfügt über zahlreiche private Felder, die IDisposable ebenfalls implementieren. In meinem Test möchte ich überprüfen, dass, wenn ich Dispose() aufrufen, es korrekt Dispose() auf alle IDisposable-Felder aufruft. Im Wesentlichen möchte ich, dass mein Komponententest wie folgt aussieht:

var o = new ObjectUnderTest(); 
o.Dispose(); 
Assert.IsFalse(ObjectHasUndisposedDisposables(o)); 

Ich dachte über Reflexion, um dies zu erreichen. Es scheint, als ob dies eine ziemlich häufige Anforderung wäre, aber ich kann keine Beispiele dafür finden.

Wer hat das versucht?

BEARBEITEN - Ich möchte nicht die Einmalartikel in die zu testende Klasse injizieren müssen.

Answer 1

Die einzige Möglichkeit, das Verhalten, das Sie suchen, ohne Refactoring in Ihrem Code zu überprüfen, ist die Verwendung von Code-Web-Tools. Typemock Isolator, MsFakes und etc ...

Der folgende Ausschnitt zeigt die Art und Weise das Verhalten mit MsFakes zu überprüfen:

[TestMethod] 
public void TestMethod1() 
{ 
    var wasCalled = false; 
    using (ShimsContext.Create()) 
    { 
     ForMsFakes.Fakes.ShimDependency.AllInstances.Dispose = dependency => 
     { 
      wasCalled = true; 
     }; 

     var o = new ObjectUnderTest(); 

     o.Dispose(); 
    } 

    Assert.IsTrue(wasCalled); 
} 

public class Dependency : IDisposable 
{ 
    public void Dispose() {} 
} 

public class ObjectUnderTest: IDisposable 
{ 
    private readonly Dependency _d = new Dependency(); 

    public void Dispose() 
    { 
     _d.Dispose(); 
    } 
} 

Answer 2

Es gibt keine generische Möglichkeit, dies zu handhaben. Die Schnittstelle IDisposeable erfordert nicht, dass Sie verfolgen, ob die Entsorgung angerufen wurde oder nicht.

Der einzige Weg, an den ich denken könnte, dass Sie damit umgehen könnten, ist, wenn all diese verfügbaren Klassen injiziert wurden, indem die Abhängigkeit injiziert wurde. Wenn Sie das getan haben, könnten Sie die injizierten Klassen verspotten und verfolgen, ob dispose aufgerufen wurde.

[TestMethod] 
    public void TestAllDisposeablesAreDisposed() 
    { 
     var fooMock = new Mock<IFoo>(); 
     fooMock.Setup(x=>x.Dispose()) 
      .Verifiable("Dispose never called on Foo"); 

     var barMock = new Mock<IBar>(); 
     barMock.Setup(x => x.Dispose()) 
      .Verifiable("Dispose never called on Bar"); 

     using (var myClass = new MyClass(fooMock.Object, barMock.Object)) 
     { 
     } 

     fooMock.Verify(); 
     barMock.Verify(); 
    } 

Answer 3

Sind Sie, ob Ihr IDisposable Verhalten innerhalb einer bestimmten Klasse arbeitet zu testen, versuchen, oder tun Sie testen möchten, ob das, was auch immer ist die Verwaltung Ihrer Wegwerf-Klasse IDisposable tatsächlich ruft? Das ist gültig, wenn Sie nicht sicher sind, dass es angerufen wird und Sie sicher sein wollen. (Ich habe für die Tests geschrieben.)

Für, dass Sie eine einfache Klasse wie folgt erstellen:

public class DisposeMe : IDisposable 
{ 
    public bool Disposed {get;set;} 
    public void Dispose() 
    { 
     Disposed = true; 
    } 
} 

Dann können Sie einfach behaupten, dass Disposed wahr ist, wenn Sie es erwarten angeordnet worden zu sein.

Zum Beispiel habe ich das verwendet, wenn ich Klassen aus einem DI-Container erstellen, und ich möchte bestätigen, dass wenn eine Klasse durch den Container freigegeben wird, seine verfügbaren Abhängigkeiten entsorgt werden. Ich kann das nicht in den konkreten Klassen nachverfolgen, aber ich kann testen, dass der DI-Container tut, was er meiner Meinung nach tun sollte. (Das ist kein Test, den ich wieder und wieder schreiben würde. Sobald ich das erwartete Verhalten von Windsor zum Beispiel bestätigt habe, werde ich keine Unit-Tests mehr schreiben.)

Answer 4

Wenn Sie nicht wollen Verwenden Sie Dependency Injection im Konstruktor, da dies Sie zwingen würde, Ihre Schnittstelle zu ändern, dann könnten Sie Ihre Abhängigkeiten über Eigenschaften injizieren. Geben Sie Ihrer Eigenschaft einen Standardwert, wenn nichts injiziert wird, so dass Sie bei der Verwendung der Klasse nicht daran denken müssen, die echte Implementierung zu übergeben, z. B. .

public class ObjectUnderTest : IDisposable 
{ 
    private IObjectNeedingDisposal _foo; 

    public IObjectNeedingDisposal Foo 
    { 
     get { return _foo ?? (_foo = new ObjectNeedingDisposal()); } 
     set { _foo = value; } 
    } 

    public void MethodUsingDisposable() 
    { 
     Foo.DoStuff(); 
    } 

    public void Dispose() 
    { 
     Foo.Dispose(); 
    } 
} 

In Ihren Tests konnte man dann eine Instanz des Objekts erstellen und in der Mock-Version Ihrer Klasse übergeben, aber in der realen Umsetzung könnte man es nicht gesetzt verlassen und es würde Sie wollten auf eine Instanz des Typs Standard