Isolando código em teste com falsificação da Microsoft

As falsificação do Microsoft ajudam você a isolar o código que você está testando substituindo outras partes do aplicativo com os modelos ou as correções.Essas são as partes de código pequenas que estão sob controle dos testes.Isolando para testar seu código, você sabe que se o teste falhar, a causa é abordado e não em outro lugar.Os modelos e as correções também permite que você teste seu código se outras partes do seu aplicativo não estão trabalhando ainda.

As falsificação vêm em dois sabores:

• stub substitui uma classe com um pequeno substituta que implementa a mesma interface.Para usar stub, você precisa criar seu aplicativo para que cada componente apenas depende das interfaces, e não em outros componentes.(Por “componente” queremos dizer uma classe ou um grupo de classes que são criadas e atualizadas juntos e normalmente contidas em um assembly.)

• correção altera o código compilado do aplicativo em tempo de execução para que em vez de fazer uma chamada de método especificado, executa o código corretivo que seu teste fornece.As correções podem ser usadas para substituir chamadas para assemblies que você não pode modificar, esses conjuntos .NET.

Requisitos

• Visual Studio Ultimate

Escolha entre o stub e os tipos de correção

Normalmente, você consideraria um projeto Visual Studio ser um componente, pois você desenvolver e atualiza as classes ao mesmo tempo.Você usar consideraria stub e correções para chamadas que o projeto faz para outros projetos na solução, ou outros assemblies que o projeto referencia.

Como um guia geral, use stub para chamadas em sua solução do Visual Studio, e correções para chamadas a outros assemblies referenciados.Isso ocorre porque dentro sua própria solução é boa prática desacoplar componentes definindo interfaces da maneira que arrancar requer.Mas os módulos (assemblies) externos como System.dll normalmente não são fornecidos com definições de interface separadas, portanto você deve usar correções em vez disso.

Outras considerações são:

Desempenho. As correções executam mais lento porque reescrevem seu código em tempo de execução.Os modelos não têm essa sobrecarga de desempenho e são tão rápido como os métodos virtuais podem ir.

Métodos estáticos, tipos selados. Você pode usar stub para implementar interfaces.Portanto, os tipos de stub não podem ser usados para métodos estáticos, não métodos virtuais, métodos virtuais selados, métodos em tipos selados, e assim por diante.

Tipos internos. Os modelos e as correções podem ser usados com tipos internos que são feitas acessíveis usando o atributo InternalsVisibleToAttributedo assembly.

Métodos particulares. As correções podem substituir chamadas para métodos particulares se todos os tipos na assinatura do método são visíveis.Os modelos podem substituir somente métodos visíveis.

Interfaces e métodos do sumário. Os modelos fornecem implementações de interfaces e métodos abstratas que podem ser usados em teste.As correções não pode instrumentar interfaces e métodos do sumário, porque eles não têm corpo do método.

Geralmente, é recomendável que você usar tipos de stub para isolar se as dependências no codebase.Você pode fazer isso ocultar os componentes code-behind interfaces.Os tipos de correção podem ser usados para isolar-se de componentes de terceiros que não fornecem API testavel.

Guia de introdução com stub

1. Insira interfaces

   Para usar stub, você tem que escrever código que você deseja testar de tal forma que não vale a pena mencionar explicitamente classes em outro componente do seu aplicativo.O component queremos dizer uma classe ou uma classes que são desenvolvidos e atualizados juntos, e contido normalmente em um projeto Visual Studio.Variáveis e parâmetros devem ser declarados usando interfaces e instâncias de outros componentes devem ser passados ou criado usando uma fábrica.Por exemplo, se StockFeed é uma classe em outro componente do aplicativo, então este é considerado incorreto:

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

   Em vez disso, defina uma interface que podem ser implementadas pelo outro componente, e que também pode ser implementada por um stub para fins de teste:

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

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

2. Adicione o conjunto de falsificação

   1. No solution Explorer, expanda a lista de referência de projeto de teste.Se você estiver trabalhando em Visual Basic, você deve escolher Mostrar todos os arquivos para ver a lista de referência.

   2. Selecione a referência ao assembly em que a interface (por exemplo IStockFeed) é definida.No menu de atalho essa referência, escolha Adicione o conjunto de falsificação.

   3. Recriar a solução.

3. Em seus testes, criar instâncias de stub e fornecer o código para os 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
   

   A parte especial de mágica aqui é a classe StubIStockFeed.Para cada interface no assembly referenciado, o mecanismo de falsificação do Microsoft gera uma classe de stub.O nome da classe stub é nomes derivados do nome da interface comFakes.Stub“,” como um prefixo, e o tipo de parâmetro anexados.

   Os modelos são também gerados para o getter e definidores propriedades, eventos para, para e métodos genéricos.Para obter mais informações, consulte Usando stubs para isolar partes de seu aplicativo para testes de unidade.

Guia de introdução com correções

Suponha que seu componente contém chamadas a DateTime.Now:

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

Durante testes, você gostaria de calçar a propriedade de Now , porque a versão atual incòmoda retorna um valor diferente em cada chamada.

Para usar correções, você não tem que alterar o código do aplicativo ou gravar uma maneira específica.

1. Adicione o conjunto de falsificação

   No solution Explorer, abra referências do projeto de teste de unidade e selecione a referência ao assembly que contém o método que você deseja falsificar.Nesse exemplo, a classe de DateTime está em System.dll.Para ver as referências no Visual Basic project, escolha Mostrar todos os arquivos.

   Escolha Adicione o conjunto de falsificação.

2. Insira uma correção em um 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
   

   Os nomes de classe corretivos são compostos Fakes.Shim prefixando o nome do tipo original.Os nomes de parâmetro é acrescentado ao nome do método.

O exemplo anterior usa uma correção para um método estático.Para usar uma correção para um método de instância, escreva AllInstances entre o nome do tipo e o nome do método:

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

Você também pode criar correções para instâncias específicas, para construtores, e para propriedades.Para obter mais informações, consulte Usando shims para isolar seu aplicativo de outros assemblies para testes de unidade.

Nesta seção

Usando stubs para isolar partes de seu aplicativo para testes de unidade

Usando shims para isolar seu aplicativo de outros assemblies para testes de unidade

Geração de código, compilação e convenções de nomenclatura no Microsoft falsificações