Unidad probando el uso de TransactionScope

Question

El preámbulo: He diseñado una clase de capa de datos fuertemente interconectado y totalmente mockable que espera que la capa de negocio para crear un TransactionScope cuando múltiples llamadas deben ser incluidos en una sola transacción.

El problema es: Me gustaría probar de forma unitaria que mi capa empresarial hace uso de un objeto TransactionScope cuando lo espero.

Por desgracia, el patrón estándar para el uso de TransactionScope es la siguiente:

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

Si bien esto es realmente un gran patrón en términos de facilidad de uso para el programador, las pruebas que se hace parece ... unpossible a mí. No puedo detectar que un objeto transitorio haya sido instanciado, y mucho menos simularlo para determinar que un método fue llamado sobre él. Sin embargo, mi objetivo de cobertura implica que debo hacerlo.

La Pregunta: ¿Cómo puedo ir construyendo unidad de pruebas que aseguran TransactionScope se usa apropiadamente de acuerdo con el patrón estándar?

Consideraciones finales: He pensado en una solución que sin duda proporcionar la cobertura que necesito, pero lo han rechazado como demasiado complejo y que no cumplan el patrón estándar TransactionScope. Implica agregar un método CreateTransactionScope en mi objeto de capa de datos que devuelve una instancia de TransactionScope. Pero como TransactionScope contiene lógica de constructor y métodos no virtuales y, por lo tanto, es difícil, si no imposible, simular, CreateTransactionScope devolvería una instancia de DataLayerTransactionScope que sería una fachada simulada en TransactionScope.

Si bien esto podría hacer el trabajo, es complejo y preferiría usar el patrón estándar. ¿Hay una mejor manera?

Answer 1

sólo estoy ahora sentado con el mismo problema y me parece que hay dos soluciones:

1. no resuelven el problema.
2. Crea abstracciones para las clases existentes que siguen el mismo patrón pero son modificables/stubable.

Editar: He creado un CodePlex-proyecto para este momento: http://legendtransactions.codeplex.com/

Me estoy inclinando hacia la creación de un conjunto de interfaces para trabajar con transacciones y una aplicación por defecto que los delegados a la System.Transaction-implementaciones, algo así como:

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

} 

Este parece ser un montón de trabajo, pero por otro lado es reutilizable y que hace que sea muy fácil comprobable.

Tenga en cuenta que esta no es la definición completa de las interfaces lo suficiente para darle una idea general.

Editar: que acabo de hacer alguna implementación rápida y sucia como una prueba de concepto, creo que esta es la dirección que va a tomar, esto es lo que he encontrado hasta el momento. Estoy pensando que tal vez debería crear un proyecto CodePlex para que el problema pueda resolverse de una vez por todas. Esta no es la primera vez que me encuentro con esto.

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

He aquí un ejemplo de una clase que depende de la ITransactionManager de manejar que es un trabajo transaccional:

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

Soy desarrollador de Java, por lo que no estoy seguro de los detalles de C#, pero me parece que aquí se necesitan dos pruebas de unidad.

La primera debe ser una prueba de "cielo azul" que tenga éxito. La prueba de unidad debe garantizar que todos los registros que son ACID aparecen en la base de datos después de que se ha confirmado la transacción.

La segunda debe ser la versión "wonky" que realiza la operación InsertFoo y luego arroja una excepción antes de intentar InsertBar. Una prueba exitosa mostrará que se ha lanzado la excepción y que ni los objetos Foo ni Bar han sido enviados a la base de datos.

Si ambos pasan, diría que su TransactionScope está funcionando como debería.

Answer 3

Haciendo caso omiso de si esta prueba es una buena cosa o no ....

truco muy sucio es comprobar que Transaction.Current no es nulo.

Esto no es una prueba del 100%, ya que alguien podría estar usando algo diferente a TransactionScope para lograr esto, pero debería evitar las partes obvias de 'no se molestó en tener una transacción'.

Otra opción es intentar deliberadamente crear un nuevo TransactionScope con nivel de aislamiento incompatible con lo que debería/debería estar en uso y TransactionScopeOption.Required.Si esto tiene éxito en lugar de arrojar una ArgumentException, no hubo una transacción. Esto requiere que usted sepa que un IsolationLevel particular no se utiliza (algo como Chaos es una elección posible)

Ninguna de estas dos opciones es particularmente agradable, esta última es muy frágil y está sujeta a la semántica de TransactionScope que se mantiene constante. Probaría lo primero en lugar de lo último, ya que es algo más robusto (y claro para leer/depurar).

Answer 4

Después de haber reflexionado sobre el mismo tema a mí, llegué a la siguiente solución.

cambiar el patrón a:

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

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

Cuando este caso es necesario para probar el código, que hereda la clase bajo prueba, la ampliación de la función, por lo que puede detectar si se invocó.

public class TestableBLLClass : BLLClass 
    { 
     public bool scopeCalled; 

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

Luego realiza las pruebas relacionadas con TransactionScope en la versión comprobable de su clase.

Answer 5

Encontré una excelente manera de probar esto usando Moq y FluentAssertions.Suponga que su unidad bajo prueba es el siguiente:

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

Su prueba sería el siguiente (suponiendo 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(); 
    } 
} 

Esto funciona muy bien para mis propósitos.