Aislar el código probado con Microsoft Fakes

Ayuda de Microsoft Fakes se aísla el código que está probando reemplazando otras partes de la aplicación con códigos auxiliares o las cuñas.Éstos son los pequeños fragmentos de código que están bajo el control de las pruebas.Aislar código para probar, sabe que en caso de error, la causa está ahí y no en alguna otra parte.Los códigos auxiliares y las cuñas también permiten probar el código aunque no trabajen otras partes de la aplicación todavía.

Las falsificaciones proceden de dos tipos:

• código auxiliar reemplaza una clase con un pequeño sustituto que implementa la misma interfaz.Para utilizar códigos auxiliares, tiene que diseñar la aplicación para que cada componente depende únicamente de interfaces, y no en otros componentes.(Por “componente” se una clase o un grupo de clases están diseñadas y se actualicen juntas y se suelen contener que en un ensamblado).

• correcciones de compatibilidad modifica el código compilado de la aplicación en tiempo de ejecución para que en lugar de realizar una llamada al método especificada, ejecute el código de correcciones de compatibilidad que pruebas proporciona.Las cuñas se pueden utilizar para reemplazar las llamadas a los ensamblados que no se puede modificar, dichos ensamblados.NET.

Requisitos

• Visual Studio Ultimate

La elección entre el código auxiliar y tipos de corrección de compatibilidad

Normalmente, se consideraría un proyecto de Visual Studio para ser un componente, porque se desarrolla y actualiza las clases al mismo tiempo.Se consideraría mediante códigos auxiliares y cuñas para las llamadas que el proyecto crea a otros proyectos en la solución, o a otros ensamblados que el proyecto hace referencia.

Como una guía general, códigos auxiliares de uso para las llamadas dentro de la solución de Visual Studio, y cuñas para las llamadas a otros ensamblados a los que se hace referencia.Esto es porque en el propietario de la solución es recomendable desacoplar componentes definiendo interfaces de la manera que el tropezar requiere.Pero los ensamblados externos como System.dll no se proporcionan normalmente definiciones de interfaz independientes, por lo que debe utilizar las cuñas en su lugar.

Otras consideraciones son:

Rendimiento. Calza el rendimiento más lento porque reescribir el código en tiempo de ejecución.Los códigos auxiliares no tienen esta sobrecarga de rendimiento y son tan rápidas como métodos virtuales pueden ir.

Métodos estáticos, tipos sellados. Sólo se puede utilizar código auxiliar para implementar interfaces.Por consiguiente, los tipos de código auxiliar no pueden utilizarse para los métodos estáticos, métodos no virtuales, métodos virtuales sellados, métodos de tipo sellado, etc.

Tipos internos. Los códigos auxiliares y las cuñas se pueden usar con los tipos internos que se hacen accesibles mediante el atributo assembly InternalsVisibleToAttribute.

Métodos privados Las cuñas pueden reemplazar llamadas a los métodos privados si todos los tipos en la firma de método están visibles.Los códigos auxiliares pueden reemplazar aquellos métodos visible.

Interfaces y métodos abstractos. Los códigos auxiliares proporcionan implementaciones de interfaces y métodos de resumen que se pueden utilizar en la prueba.Las cuñas no pueden instrumentar interfaces y métodos de resumen, porque no tienen cuerpos de método.

Por lo general, nosotros recomendamos que se utilicen tipos de código auxiliar para aislarse de dependencias dentro del código base.Se puede hacer ocultando los componentes básicos de interfaces.Los tipos de corrección de compatibilidad pueden utilizarse para aislarse de los componentes de terceros que no proporcionan APIs comprobables.

Introducción al códigos auxiliares

1. Inserte las interfaces

   Para utilizar códigos auxiliares, tiene que escribir el código que desea probar de manera que no mencione clases a otro componente de aplicación.Por “componente” se una clase o clases que se desarrollan y se actualizan juntos, y contenido normalmente en un proyecto de Visual Studio.Las variables y los parámetros se deben declarar con interfaces e instancias de otros componentes deben pasarse en o crear mediante un generador.Por ejemplo, si StockFeed es una clase de otro componente de la aplicación, entonces esto sería considerada como erróneo:

   return (new StockFeed()).GetSharePrice("COOO"); // Bad

   En su lugar, defina una interfaz que se pueden implementar por otro componente, y que también puede implementarse por un código auxiliar para evaluación:

   public int GetContosoPrice(IStockFeed feed)
   { return feed.GetSharePrice("COOO"); }
   

   Public Function GetContosoPrice(feed As IStockFeed) As Integer
    Return feed.GetSharePrice("COOO")
   End Function
   

2. Agregue el ensamblado de las falsificaciones

   1. En el explorador de soluciones, expanda la lista de referencia del proyecto de prueba.Si está trabajando en Visual Basic, debe elegir mostrar todos los archivos para ver la lista de referencias.

   2. Seleccione la referencia al ensamblado donde se define la interfaz (por ejemplo IStockFeed).En el menú contextual de esta referencia, elija Agregue el ensamblado de las falsificaciones.

   3. Recompilar la solución.

3. En las pruebas, cree instancias de código auxiliar y proporcione código para sus métodos:

   [TestClass]
   class TestStockAnalyzer
   {
       [TestMethod]
       public void TestContosoStockPrice()
       {
         // Arrange:
   
           // Create the fake stockFeed:
           IStockFeed stockFeed = 
                new StockAnalysis.Fakes.StubIStockFeed() // Generated by Fakes.
                    {
                        // Define each method:
                        // Name is original name + parameter types:
                        GetSharePriceString = (company) => { return 1234; }
                    };
   
           // In the completed application, stockFeed would be a real one:
           var componentUnderTest = new StockAnalyzer(stockFeed);
   
         // Act:
           int actualValue = componentUnderTest.GetContosoPrice();
   
         // Assert:
           Assert.AreEqual(1234, actualValue);
       }
       ...
   }
   

   <TestClass()> _
   Class TestStockAnalyzer
   
       <TestMethod()> _
       Public Sub TestContosoStockPrice()
           ' Arrange:
           ' Create the fake stockFeed:
           Dim stockFeed As New StockAnalysis.Fakes.StubIStockFeed
           With stockFeed
               .GetSharePriceString = Function(company)
                                          Return 1234
                                      End Function
           End With
           ' In the completed application, stockFeed would be a real one:
           Dim componentUnderTest As New StockAnalyzer(stockFeed)
           ' Act:
           Dim actualValue As Integer = componentUnderTest.GetContosoPrice
           ' Assert:
           Assert.AreEqual(1234, actualValue)
       End Sub
   End Class
   

   El fragmento especial de magia aquí es la clase StubIStockFeed.Para cada interfaz en el ensamblado hace referencia, el mecanismo de Microsoft Fakes genera una clase de código auxiliar.El nombre de la clase de código auxiliar es los nombres derivados del nombre de la interfaz, con “Fakes.Stub” como prefijo, y el tipo de parámetro anexados.

   Los códigos auxiliares también se generan para captadores y los establecedores de propiedades, para los eventos, y para métodos genéricos.Para obtener más información, vea Usar stubs para aislar las partes de la aplicación entre sí para las pruebas unitarias.

Introducción al las cuñas

Supongamos que el componente contiene las llamadas a DateTime.Now:

// Code under test:
    public int GetTheCurrentYear()
    {
       return DateTime.Now.Year;
    }

Durante la prueba, desea calzar la propiedad de Now, porque la versión real devuelve complicados un valor diferente en cada llamada.

Para utilizar las cuñas, no tiene que modificar el código de aplicación o escribir una forma determinada.

1. Agregue el ensamblado de las falsificaciones

   En el explorador de soluciones, abra las referencias del proyecto de prueba unitaria y seleccione la referencia al ensamblado que contiene el método que desee imitar.En este ejemplo, la clase de DateTime está en System.dll.Para ver las referencias de un proyecto de Visual Basic, elija mostrar todos los archivos.

   Elija Agregue el ensamblado de las falsificaciones.

2. Inserte un correcciones de compatibilidad en un ShimsContext

   [TestClass]
   public class TestClass1
   { 
           [TestMethod]
           public void TestCurrentYear()
           {
               int fixedYear = 2000;
   
               // Shims can be used only in a ShimsContext:
               using (ShimsContext.Create())
               {
                 // Arrange:
                   // Shim DateTime.Now to return a fixed date:
                   System.Fakes.ShimDateTime.NowGet = 
                   () =>
                   { return new DateTime(fixedYear, 1, 1); };
   
                   // Instantiate the component under test:
                   var componentUnderTest = new MyComponent();
   
                 // Act:
                   int year = componentUnderTest.GetTheCurrentYear();
   
                 // Assert: 
                   // This will always be true if the component is working:
                   Assert.AreEqual(fixedYear, year);
               }
           }
   }
   

   <TestClass()> _
   Public Class TestClass1
       <TestMethod()> _
       Public Sub TestCurrentYear()
           Using s = Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create()
               Dim fixedYear As Integer = 2000
               ' Arrange:
               ' Detour DateTime.Now to return a fixed date:
               System.Fakes.ShimDateTime.NowGet = _
                   Function() As DateTime
                       Return New DateTime(fixedYear, 1, 1)
                   End Function
   
               ' Instantiate the component under test:
               Dim componentUnderTest = New MyComponent()
               ' Act:
               Dim year As Integer = componentUnderTest.GetTheCurrentYear
               ' Assert: 
               ' This will always be true if the component is working:
               Assert.AreEqual(fixedYear, year)
           End Using
       End Sub
   End Class
   

   Los nombres de clase de correcciones de compatibilidad son compuestos anteponiendo Fakes.Shim al nombre de tipo original.Los nombres de parámetro se anexan al nombre del método.

El ejemplo anterior utiliza un correcciones de compatibilidad para un método estático.Para utilizar un correcciones de compatibilidad para un método de instancia, escriba AllInstances entre el nombre del tipo y el nombre del método:

System.IO.Fakes.ShimFile.AllInstances.ReadToEnd = ...

También puede crear las cuñas para instancias concretas, para los constructores, y para las propiedades.Para obtener más información, vea Usar correcciones de compatibilidad (shim) para aislar la aplicación de otros ensamblados para las pruebas unitarias.

En esta sección

Usar stubs para aislar las partes de la aplicación entre sí para las pruebas unitarias

Usar correcciones de compatibilidad (shim) para aislar la aplicación de otros ensamblados para las pruebas unitarias

Generación de código, compilación y convenciones de nomenclatura en Microsoft Fakes