Mocking eine Linq2Sql DataContext

Da Sie eine Art und Weise zu verspotten, ein DataContext ich davon ausgehen, dass Sie wirklich wollen, zu tun, einige unit-tests und nicht-integration-tests.

Gut, ich werde Ihnen sagen, wie dies zu erreichen, aber zuerst möchte ich Sie ermutigen, Lesen Sie die folgenden links, Sie sind alle über sauber schreiben von testbarem code.

• http://misko.hevery.com/code-reviewers-guide/

• http://misko.hevery.com/attachments/Guide-Writing%20Testable%20Code.pdf

Und überprüfen Sie die links, die von dieser Reaktion:

• https://stackoverflow.com/a/10359288/1268570

Watch the clean code talks von Misko Hevery (gegeben auf der Google-Leute)

• http://www.youtube.com/watch?v=wEhu57pih5w&feature=player_embedded

• http://www.youtube.com/watch?v=RlfLCWKxHJ0&feature=player_embedded

• http://www.youtube.com/watch?v=-FRm3VPhseI&feature=player_embedded

• http://www.youtube.com/watch?v=4F72VULWFvc&feature=player_embedded

Eine Sache, die ich wiederholt zu mir selbst und zu meinen Mitmenschen bei der Arbeit, ist, dass jeder kann schreiben unit Tests, denn Sie sind dumm, einfach zu schreiben. So ein einfacher test ist, im wesentlichen alle über einige Vergleiche und Ausnahmen werfen, wenn das Ergebnis ausfällt, das kann jeder. Natürlich, es gibt Hunderte von frameworks, die uns helfen, schreiben Sie diese tests in einer elegante Weise. Aber das wirkliche Angebot und die wirkliche Anstrengung Leichentuch auf erfahren Sie, wie rein zu schreiben von testbarem code

Selbst wenn Sie mieten Misko Hevery, um Ihnen helfen, einen Test schreiben, hat er eine echt harte Zeit, Sie zu schreiben, wenn Ihr code ist nicht getestet-freundlich.

Nun den Weg zu mock ein DataContext Objekte ist: tun Sie es nicht

Stattdessen wickeln Sie die Anrufe über eine benutzerdefinierte Schnittstelle statt:

public interface IMyDataContextCalls
{
    void Save();
    IEnumerable<Product> GetOrders();
}
//this will be your DataContext wrapper
//this wll act as your domain repository
public class MyDataContextCalls : IMyDataContextCalls
{
    public MyDataContextCalls(DataClasses1DataContext context)
    {
        this.Context = context;
    }

    public void Save()
    {
        this.Context.SubmitChanges();
    }

    public IEnumerable<Product> GetOrders()
    {
        //place here your query logic
        return this.Context.Products.AsEnumerable();
    }


    private DataClasses1DataContext Context { get; set; }

}

//this will be your domain object
//this object will call your repository wrapping the DataContext
public class MyCommand
{
    private IMyDataContextCalls myDataContext;
    public MyCommand(IMyDataContextCalls myDataContext)
    {
        this.myDataContext = myDataContext;
    }

    public bool myDomainRule = true;

    //assume this will be the SUT (Subject Under Test)
    public void Save()
    {
        //some business logic
        //this logic will be tested
        if (this.myDomainRule == true)
        {
            this.myDataContext.Save();
        }
        else
        {
            //handle your domain validation  errors
            throw new InvalidOperationException();
        }
    }
}

[TestClass]
public class MyTestClass
{
    [TestMethod]
    public void MyTestMethod()
    {
        //in this test your mission is to test the logic inside the 
        //MyCommand.Save method
        //create the mock, you could use a framework to auto mock it
        //or create one manually
        //manual example:
        var m = new MyCommand(new MyFakeDataContextFake());

        m.Invoking(x => x.Save())
            //add here more asserts, maybe asserting that the internal
            //state of your domain object was changed
            //your focus is to test the logic of the domain object
            .ShouldNotThrow();

        //auto mock example:
        var fix = new Fixture().Customize(new AutoMoqCustomization());
        var sut = fix.CreateAnonymous<MyCommand>();
        sut.myDomainRule = false;

        sut.Invoking(x => x.Save())
            .ShouldThrow<InvalidOperationException>();
    }

    public class MyFakeDataContextFake : IMyDataContextCalls
    {
        public void Save()
        {
            //do nothing, since you do not care in the logic of this method,
            //remember your goal is to test the domain object logic
        }

        public IEnumerable<Product> GetOrders()
        {
            //we do not care on this right now because we are testing only the save method

            throw new NotImplementedException();
        }
    }
}

Hinweise:

• Wenn Sie erklären Ihre IMyDataContextCalls Schnittstelle, die Sie tatsächlich die Abstraktion der Verwendung einer DataContext daher diese Schnittstelle sollte nur POCO-Objekte (die meiste Zeit), wenn Sie diesem Ansatz Folgen Ihrer Schnittstellen wird entkoppelt von ungewünschten Abhängigkeiten.

• In der spezifischen MyDataContextCalls Umsetzung, Sie sind ausdrücklich mit ein DataClasses1DataContext Zusammenhang, aber Sie sind frei, zu ändern, die Durchführung zu jeder Zeit, und dass keinen Einfluss auf Ihre externen code, und das ist, weil Sie arbeiten immer mit der IMyDataContextCalls - Schnittstelle statt. So hat man jederzeit ändern könnte dies beispielsweise für die Umsetzung einer anderen mit der wunderbaren NHibernate =) oder die Armen ef oder ein mock einer

• Endlich, aber nicht zuletzt. überprüfen Sie bitte mein code, und Sie werden feststellen, dass es gibt keine new Betreiber in die domain-Objekte. Dies ist in der Regel zu dumm beim schreiben von test-freundlichen code: entkoppeln die Verantwortung für die Erstellung von Objekten außerhalb Ihrer domain Objekte

Ich persönlich benutze drei frameworks, die auf jedes Projekt und auf jeden test, den ich Schreibe, werde ich wirklich empfehlen:

• AutoFixture

• Moq

• FluentAssertions

Zum Beispiel, im code oben, ich habe Ihnen gezeigt, wie Sie schreiben, ein Handbuch fake für Ihr repository, aber das ist offenbar etwas, was wir nicht tun wollen in einem realen Projekt, vorstellen, die Zahl der Objekte, die Sie haben würde, um code, um zu schreiben Ihre tests.

Stattdessen nutzen Sie die Kraft von AutoFixture kombiniert mit Moq:

Diese Zeile: var m = new MyCommand(new MyFakeDataContextFake());

Werden:

        var fixture = new Fixture().Customize(new AutoMoqCustomization());
        var sut = fixture.CreateAnonymous<MyCommand>();

... Und das ist es, wird dieser code automatisch erstellen von mocks für alle Objekte benötigt, die im Konstruktor der MyCommand.