Wie unit test eine Methode mit einer `mit` - Anweisung?

Wenn Sie bereits Ihre Codes und Fragen, wie es zu testen, dann bist du nicht schreiben Ihres ersten tests...also nicht wirklich zu tun TDD.

Jedoch, was Sie hier haben, ist eine Abhängigkeit. So der TDD-Ansatz wäre die Verwendung Dependency Injection. Dies kann gemacht werden einfacher, mit einem IoC container wie Einheit.

Wenn dabei TDD "richtig", Ihre Denkprozesse laufen sollte wie folgt in diese Art von Szenario:

• Ich muss Foo
• Für dieses ich wird sich auf einem externen Abhängigkeit, wird eine Schnittstelle implementieren (neues oder bereits bestehendes) von IMyDisposableClass
• Daher werde ich Spritzen ein IMyDisposableClass in der Klasse, in der Foo deklariert ist über seinen Konstruktor

Dann schreiben Sie eine (oder mehrere) tests, die fehlschlagen, und nur dann wären Sie an der Stelle, wo Sie schreiben Foo Funktion Körper, und bestimmen, ob Sie benötigt using block.

In der Realität könnten Sie auch wissen, dass ja, Sie verwenden eine using block. Aber der Sinn von TDD ist, dass Sie brauchen nicht zu befürchten, dass, bis Sie bewiesen haben (durch tests), dass Sie tun müssen, verwenden Sie ein Objekt, die dieser verlangt.

Sobald Sie festgestellt haben, dass Sie brauchen, um eine using blockieren würden Sie dann wollen, einen test schreiben, der fehlschlägt - zum Beispiel mit so etwas wie Rhino Mocks auf die Erwartung, dass Dispose wird aufgerufen, auf ein mock-Objekt implementiert IMyDisposableClass.

Beispiel (mit Rhino Mocks zu verspotten IMyDisposableClass).

[TestFixture]
public class When_calling_Foo
{
    [Test]
    public void Should_call_Dispose()
    {
        IMyDisposableClass disposable = MockRepository
                                        .GenerateMock<IMyDisposableClass>();

        Stuff stuff = new Stuff(disposable);

        stuff.Foo();

        disposable.AssertWasCalled(x => x.Dispose());
    }
}

Klasse, in der Sie Ihre Foo-Funktion vorhanden ist, mit IMyDisposableClass eingespritzt Abhängigkeit:

public class Stuff
{
    private readonly IMyDisposableClass _client;

    public Stuff(IMyDisposableClass client)
    {
        _client = client;
    }

    public bool Foo()
    {
        using (_client)
        {
            return _client.SomeOtherMethod();
        }
    }
}

Und die Schnittstelle IMyDisposableClass

public interface IMyDisposableClass : IDisposable
{
    bool SomeOtherMethod();
}

Wrapper-Methoden wie die, die nicht unit-getestet werden, denn Sie können nicht geben Sie die relevanten Vorbedingungen oder nachbedingungen.

Wird die Methode getestet, haben Sie, um eine IMyDisposableClass - Instanz in der Methode oder in der Klasse-hosting Foo (und die host-Klasse selbst implementieren IDisposable), so können Sie eine test-Doppel statt die Reale Sache, um zu überprüfen, mögliche Interaktionen mit ihm.

Wenn Sie den Test Foo, dann sollten Sie einen Blick auf die Ausgabe von Foo, nicht sich Gedanken über die Entsorgung der Klasse ist es mit intern.

Wenn Sie testen möchten MyDisposableClass' dispose-Methode, um zu sehen, ob es funktioniert, sollte eine separate Einheit test gebaut gegen MyDisposableClass.

Brauchen Sie nicht, um unit-test der using { } block, denn das ist Teil der Sprache. Sie entweder darauf Vertrauen, dass es funktioniert, oder nicht C# verwenden. 🙂 Ich sehe nicht die Notwendigkeit, zu schreiben unit Tests, um zu überprüfen, dass Dispose() aufgerufen wird.