Einheit Testen der Verwendung von Transaction

Question

der Präambel: ich eine stark angeschlossen und voll Schichtklasse mockable Daten ausgelegt sind, dass die Business-Schicht sollte in einer einzigen Transaktion einbezogen werden ein TransactionScope, wenn mehrere Anrufe erstellen erwartet.

Das Problem: Ich möchte Einheit testen, dass meine Business-Schicht ein TransactionScope Objekt verwendet, wenn ich es erwarte.

Leider ist das Standardmuster TransactionScope für die Verwendung ist wie folgt:

using(var scope = new TransactionScope()) 
{ 
    // transactional methods 
    datalayer.InsertFoo(); 
    datalayer.InsertBar(); 
    scope.Complete(); 
} 

Zwar ist dies eine wirklich große Muster in Bezug auf Benutzerfreundlichkeit für den Programmierer ist, die Prüfung, dass es fertig ist scheint ... unpossible mir. Ich kann nicht feststellen, dass ein transientes Objekt instanziiert wurde, geschweige denn es verspotten, um festzustellen, dass eine Methode dafür aufgerufen wurde. Doch mein Ziel für die Berichterstattung bedeutet, dass ich muss.

Die Frage: Wie kann ich über das Erstellen von Unit-Tests gehen, die sicherstellen, TransactionScope wird entsprechend entsprechend dem Standardmuster verwendet?

Final Thoughts: Ich habe eine Lösung in Betracht gezogen, die sicherlich die Abdeckung bieten würde ich brauche, aber haben es als zu komplex abgelehnt und nicht dem Standard TransactionScope Muster entspricht. Es beinhaltet eine CreateTransactionScope Methode für mein Datenschichtobjekt, die eine Instanz von TransactionScope zurückgibt. Aber da TransactionScope Konstruktorlogik und nicht-virtuelle Methoden enthält und daher schwierig, wenn nicht unmöglich zu mocksen ist, würde CreateTransactionScope eine Instanz DataLayerTransactionScope zurückgeben, die eine anschauliche Fassade in TransactionScope wäre.

Während dies den Job erledigen könnte, ist es komplex und ich würde lieber das Standardmuster verwenden. Gibt es einen besseren Weg?

Answer 1

Ich bin jetzt nur noch mit dem gleichen Problem zu sitzen und mir scheint es zwei Lösungen zu sein:

1. Sie das Problem nicht lösen.
2. Erstellen Sie Abstraktionen für die vorhandenen Klassen, die dem gleichen Muster folgen, aber mockbar/stubable sind.

Edit: ich ein CodePlex-Projekt für das jetzt erstellt haben: Ich bin Neigung in Richtung mit Transaktionen für die Arbeit eine Reihe von Schnittstellen zu schaffen und eine Standardimplementierung http://legendtransactions.codeplex.com/

dass die Delegierten System.Transaction-Implementierungen, so etwas wie:

public interface ITransactionManager 
{ 
    ITransaction CurrentTransaction { get; } 
    ITransactionScope CreateScope(TransactionScopeOption options); 
} 

public interface ITransactionScope : IDisposable 
{ 
    void Complete(); 
} 

public interface ITransaction 
{ 
    void EnlistVolatile(IEnlistmentNotification enlistmentNotification); 
} 

public interface IEnlistment 
{ 
    void Done(); 
} 

public interface IPreparingEnlistment 
{ 
    void Prepared(); 
} 

public interface IEnlistable // The same as IEnlistmentNotification but it has 
          // to be redefined since the Enlistment-class 
          // has no public constructor so it's not mockable. 
{ 
    void Commit(IEnlistment enlistment); 
    void Rollback(IEnlistment enlistment); 
    void Prepare(IPreparingEnlistment enlistment); 
    void InDoubt(IEnlistment enlistment); 

} 

Dies scheint eine Menge Arbeit, aber auf der anderen Seite ist es wieder verwendbar und es macht es sehr leicht prüfbar.

Beachten Sie, dass dies nicht die vollständige Definition der Schnittstellen gerade genug ist, um Ihnen das große Bild zu geben.

Edit: Ich habe gerade ein paar schnelle und schmutzige Implementierung als Proof of Concept, ich denke, das ist die Richtung, nehme ich, hier ist was ich mit so weit habe kommen. Ich denke, dass ich vielleicht ein CodePlex-Projekt dafür erstellen sollte, damit das Problem ein für allemal gelöst werden kann. Dies ist nicht das erste Mal, dass ich darauf gestoßen bin.

public interface ITransactionManager 
{ 
    ITransaction CurrentTransaction { get; } 
    ITransactionScope CreateScope(TransactionScopeOption options); 
} 

public class TransactionManager : ITransactionManager 
{ 
    public ITransaction CurrentTransaction 
    { 
     get { return new DefaultTransaction(Transaction.Current); } 
    } 

    public ITransactionScope CreateScope(TransactionScopeOption options) 
    { 
     return new DefaultTransactionScope(new TransactionScope()); 
    } 
} 

public interface ITransactionScope : IDisposable 
{ 
    void Complete(); 
} 

public class DefaultTransactionScope : ITransactionScope 
{ 
    private TransactionScope scope; 

    public DefaultTransactionScope(TransactionScope scope) 
    { 
     this.scope = scope; 
    } 

    public void Complete() 
    { 
     this.scope.Complete(); 
    } 

    public void Dispose() 
    { 
     this.scope.Dispose(); 
    } 
} 

public interface ITransaction 
{ 
    void EnlistVolatile(Enlistable enlistmentNotification, EnlistmentOptions enlistmentOptions); 
} 

public class DefaultTransaction : ITransaction 
{ 
    private Transaction transaction; 

    public DefaultTransaction(Transaction transaction) 
    { 
     this.transaction = transaction; 
    } 

    public void EnlistVolatile(Enlistable enlistmentNotification, EnlistmentOptions enlistmentOptions) 
    { 
     this.transaction.EnlistVolatile(enlistmentNotification, enlistmentOptions); 
    } 
} 


public interface IEnlistment 
{ 
    void Done(); 
} 

public interface IPreparingEnlistment 
{ 
    void Prepared(); 
} 

public abstract class Enlistable : IEnlistmentNotification 
{ 
    public abstract void Commit(IEnlistment enlistment); 
    public abstract void Rollback(IEnlistment enlistment); 
    public abstract void Prepare(IPreparingEnlistment enlistment); 
    public abstract void InDoubt(IEnlistment enlistment); 

    void IEnlistmentNotification.Commit(Enlistment enlistment) 
    { 
     this.Commit(new DefaultEnlistment(enlistment)); 
    } 

    void IEnlistmentNotification.InDoubt(Enlistment enlistment) 
    { 
     this.InDoubt(new DefaultEnlistment(enlistment)); 
    } 

    void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment) 
    { 
     this.Prepare(new DefaultPreparingEnlistment(preparingEnlistment)); 
    } 

    void IEnlistmentNotification.Rollback(Enlistment enlistment) 
    { 
     this.Rollback(new DefaultEnlistment(enlistment)); 
    } 

    private class DefaultEnlistment : IEnlistment 
    { 
     private Enlistment enlistment; 

     public DefaultEnlistment(Enlistment enlistment) 
     { 
      this.enlistment = enlistment; 
     } 

     public void Done() 
     { 
      this.enlistment.Done(); 
     } 
    } 

    private class DefaultPreparingEnlistment : DefaultEnlistment, IPreparingEnlistment 
    { 
     private PreparingEnlistment enlistment; 

     public DefaultPreparingEnlistment(PreparingEnlistment enlistment) : base(enlistment) 
     { 
      this.enlistment = enlistment;  
     } 

     public void Prepared() 
     { 
      this.enlistment.Prepared(); 
     } 
    } 
} 

Hier ist ein Beispiel einer Klasse, die auf dem ITransactionManager hängt es zu handhaben Transaktions Arbeit:

public class Foo 
{ 
    private ITransactionManager transactionManager; 

    public Foo(ITransactionManager transactionManager) 
    { 
     this.transactionManager = transactionManager; 
    } 

    public void DoSomethingTransactional() 
    { 
     var command = new TransactionalCommand(); 

     using (var scope = this.transactionManager.CreateScope(TransactionScopeOption.Required)) 
     { 
      this.transactionManager.CurrentTransaction.EnlistVolatile(command, EnlistmentOptions.None); 

      command.Execute(); 
      scope.Complete(); 
     } 
    } 

    private class TransactionalCommand : Enlistable 
    { 
     public void Execute() 
     { 
      // Do some work here... 
     } 

     public override void Commit(IEnlistment enlistment) 
     { 
      enlistment.Done(); 
     } 

     public override void Rollback(IEnlistment enlistment) 
     { 
      // Do rollback work... 
      enlistment.Done(); 
     } 

     public override void Prepare(IPreparingEnlistment enlistment) 
     { 
      enlistment.Prepared(); 
     } 

     public override void InDoubt(IEnlistment enlistment) 
     { 
      enlistment.Done(); 
     } 
    } 
} 

Answer 2

Ich bin ein Java-Entwickler, also bin ich unsicher über die C# -Details, aber es scheint mir, dass Sie hier zwei Komponententests benötigen.

Der erste sollte ein "blauer Himmel" -Test sein, der erfolgreich ist. Ihr Komponententest sollte sicherstellen, dass alle Datensätze, die ACID sind, in der Datenbank angezeigt werden, nachdem die Transaktion festgeschrieben wurde.

Die zweite sollte "wonky" Version sein, die die InsertFoo-Operation ausführt und dann eine Ausnahme auslöst, bevor Sie die InsertBar versuchen. Ein erfolgreicher Test zeigt, dass die Ausnahme ausgelöst wurde und dass weder die Foo- noch die Bar-Objekte an die Datenbank übergeben wurden.

Wenn diese beiden bestehen, würde ich sagen, dass Ihr TransactionScope funktioniert, wie es sollte.

Answer 3

ignorierend, ob dieser Test eine gute Sache ist oder nicht ....

Very dirty Hack ist, dass Transaction.Current zu überprüfen, ist nicht null.

Dies ist kein 100% -Test, da jemand etwas anderes als TransactionScope verwenden könnte, um dies zu erreichen, aber es sollte vor den offensichtlichen "keine Mühe, eine Transaktion zu haben" Teile schützen.

Eine andere Option besteht darin, absichtlich zu versuchen, ein neues TransactionScope mit inkompatibler Isolationsstufe zu dem zu erstellen, was in Verwendung sein sollte und TransactionScopeOption.Required.Wenn dies gelingt, anstatt eine ArgumentException auszulösen, gab es keine Transaktion. Dies erfordert, dass Sie wissen, dass eine bestimmte IsolationLevel nicht verwendet wird (etwas wie Chaos ist eine mögliche Wahl)

Keine dieser beiden Optionen ist besonders angenehm, letztere ist sehr anfällig und unterliegt der Semantik von TransactionScope konstant bleiben. Ich würde das erstere anstelle des letzteren testen, da es etwas robuster ist (und klar zu lesen/zu debuggen).

Answer 4

Nachdem ich mich durch das gleiche Problem gedacht zu haben, kam ich zu folgenden Lösung.

Ändern Sie das Muster auf:

using(var scope = GetTransactionScope()) 
{ 
    // transactional methods 
    datalayer.InsertFoo(); 
    datalayer.InsertBar(); 
    scope.Complete(); 
} 

protected virtual TransactionScope GetTransactionScope() 
{ 
    return new TransactionScope(); 
} 

Wenn Sie dann Ihren Code testen müssen, erben Sie die Klasse im Test, die Funktion erstreckt, so dass Sie erkennen können, wenn sie aufgerufen wurde.

public class TestableBLLClass : BLLClass 
    { 
     public bool scopeCalled; 

     protected override TransactionScope GetTransactionScope() 
     { 
      this.scopeCalled = true; 
      return base.GetTransactionScope(); 
     } 
    } 

Anschließend führen Sie die Tests in Bezug auf TransactionScope in der testbaren Version Ihrer Klasse durch.

Answer 5

Ich fand eine gute Möglichkeit, dies mit Moq und FluentAssertions zu testen.Angenommen, Ihr Gerät unter Test wie folgt aussieht:

public class Foo 
{ 
    private readonly IDataLayer dataLayer; 

    public Foo(IDataLayer dataLayer) 
    { 
     this.dataLayer = dataLayer; 
    } 

    public void MethodToTest() 
    { 
     using (var transaction = new TransactionScope()) 
     { 
      this.dataLayer.Foo(); 
      this.dataLayer.Bar(); 
      transaction.Complete(); 
     } 
    } 
} 

Ihr Test würde wie folgt aussehen (vorausgesetzt, MS Test):

[TestClass] 
public class WhenMethodToTestIsCalled() 
{ 
    [TestMethod] 
    public void ThenEverythingIsExecutedInATransaction() 
    { 
     var transactionCommitted = false; 
     var fooTransaction = (Transaction)null; 
     var barTransaction = (Transaction)null; 

     var dataLayerMock = new Mock<IDataLayer>(); 

     dataLayerMock.Setup(dataLayer => dataLayer.Foo()) 
        .Callback(() => 
           { 
            fooTransaction = Transaction.Current; 
            fooTransaction.TransactionCompleted += 
             (sender, args) => 
             transactionCommitted = args.Transaction.TransactionInformation.Status == TransactionStatus.Committed; 
           }); 

     dataLayerMock.Setup(dataLayer => dataLayer.Bar()) 
        .Callback(() => barTransaction = Transaction.Current); 

     var unitUnderTest = new Foo(dataLayerMock.Object); 

     unitUnderTest.MethodToTest(); 

     // A transaction was used for Foo() 
     fooTransaction.Should().NotBeNull(); 

     // The same transaction was used for Bar() 
     barTransaction.Should().BeSameAs(fooTransaction); 

     // The transaction was committed 
     transactionCommitted.Should().BeTrue(); 
    } 
} 

Das ist für meine Zwecke funktioniert gut.