Use o teste de IU codificado para testar seu código

CUITs (testes de IU codificados) impulsionam seu aplicativo por meio de sua IU (interface do usuário). Entre esses testes estão testes funcionais dos controles de interface de usuário. Eles permitem verificar se todo o aplicativo, inclusive sua interface do usuário, está funcionando corretamente. Os testes de IU codificados são úteis quando há validação ou outra lógica na interface do usuário, como em uma página da Web. Eles também costumam ser usados para automatizar um teste manual existente.

Criar um teste de IU codificado no Visual Studio é fácil. Basta realizar o teste manualmente enquanto o Construtor de Teste de IU Codificado é executado em segundo plano. Também é possível especificar quais valores devem ser exibidos em campos específicos. O Construtor de Teste de IU Codificado registra suas ações e gera código com base nelas. Depois que o teste for criado, será possível editá-lo em um editor especializado que permite modificar a sequência de ações.

O Construtor de Teste de IU Codificado especializado e o editor facilitam a criação e a edição de testes IU codificado mesmo que suas habilidades principais estejam concentradas em testes, e não em codificação. Mas, se você for um desenvolvedor e quiser estender o teste de maneira mais avançada, o código será estruturado para simplificar a cópia e a adaptação. Por exemplo, convém registrar um teste para comprar algo em um site e editar o código gerado para adicionar um loop que compre muitos itens.

Observação

O teste de IU codificado para teste funcional controlado por interface do usuário automatizado foi preterido. O Visual Studio 2019 será a última versão em que o teste de IU codificado estará disponível. É recomendável usar o Selenium para testar aplicativos Web e Appium com WinAppDriver para testar aplicativos de área de trabalho e da UWP. Considere Xamarin.UITest para testar aplicativos iOS e Android usando a estrutura de teste NUnit.

Requisitos

  • Visual Studio Enterprise
  • Componente de teste de IU codificado

Para obter mais informações sobre quais plataformas e configurações têm suporte em testes de interface do usuário codificados, consulte plataformas com suporte.

Instalar o componente de teste de IU codificado

Para acessar as ferramentas e os modelos de teste de interface do usuário codificados, instale o componente de teste de interface do usuário codificado do Visual Studio.

  1. Inicie o Instalador do Visual Studio escolhendo Ferramentas > Obter Ferramentas e Recursos.

  2. No Instalador do Visual Studio, escolha a guia Componentes individuais e, em seguida, role para baixo até a seção Depuração e testes. Selecione o componente Teste de IU Codificado.

    Componente de teste de IU codificado

  3. Selecione Modificar.

Criar um teste de IU codificado

  1. Crie um projeto de teste de IU codificado.

    Os testes de IU codificados devem estar contidos em um projeto de teste de IU codificado. Se você ainda não tiver um projeto de teste de IU codificado, crie um. Escolha arquivo > novo > projeto. Pesquise o modelo de Projeto de Teste de IU Codificado e selecione-o.

    Modelo de projeto de teste de IU codificado na caixa de diálogo Novo Projeto

    Observação

    Se o modelo Projeto de Teste de IU Codificado não for exibido, será necessário instalar o componente Teste de IU Codificado.

  2. Adicione um arquivo de teste de IU codificado.

    Se tiver acabado de criar um projeto de IU codificado, o primeiro arquivo CUIT será adicionado automaticamente. Para adicionar outro arquivo de teste, abra o menu de atalho no projeto de teste de interface do usuário codificado no Gerenciador de soluções e escolha Adicionar > teste de IU codificado.

    Na caixa de diálogo Gerar Código para Teste de IU Codificado, escolha Registrar ações > Editar o mapa de interface do usuário ou adicionar declarações.

    Caixa de diálogo Gerar Código para Teste de IU Codificado

    O Construtor de Teste de IU Codificado é exibido.

    Construtor de Teste de IU Codificado

  3. Registre uma sequência de ações.

    Para começar a registrar, escolha o ícone Registrar. Realize as ações que você quer testar no aplicativo, inclusive iniciá-lo, se isso for necessário. Por exemplo, se você estiver testando um aplicativo Web, convém iniciar um navegador, navegar até o site e entrar no aplicativo.

    Para pausar o registro, por exemplo, se você precisar lidar com emails recebidos, escolha Pausar.

    Aviso

    Todas as ações realizadas na área de trabalho serão registradas. Pause a gravação se estiver realizando ações que possam levar à exclusão de dados confidenciais na gravação.

    Para excluir ações registradas por equívoco, escolha Editar Etapas.

    Para gerar um código que replicará as ações, escolha o ícone Gerar Código e digite um nome e uma descrição para o método de teste de IU codificado.

  4. Verifique os valores nos campos de interface do usuário, como caixas de texto.

    Escolha Adicionar asserções no Construtor de teste de interface do usuário codificado e escolha um controle de interface do usuário em seu aplicativo em execução. Na lista de propriedades exibida, selecione uma propriedade, por exemplo, Texto em uma caixa de texto. No menu de atalho, escolha Adicionar Asserção. Na caixa de diálogo, selecione o operador de comparação, o valor de comparação e a mensagem de erro.

    Feche a janela de asserção e escolha Gerar Código.

    Elemento de destino do teste de IU codificado

    Dica

    Alterne entre o registro de ações e a verificação de valores. Gere códigos no final de cada sequência de ações ou verificações. Se quiser, você poderá inserir novas ações e verificações depois.

    Para obter mais detalhes, confira Validar as propriedades de controles.

  5. Exiba o código de teste gerado.

    Para exibir o código gerado, feche a janela Construtor de Teste de IU. No código, é possível ver os nomes que você deu a cada etapa. O código está no arquivo CUIT que você criou:

    [CodedUITest]
    public class CodedUITest1
    { ...
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          this.UIMap.VerifyResultValue();
          // To generate more code for this test, select
          // "Generate Code" from the shortcut menu.
      }
    }
    
  6. Adicione mais ações e asserções.

    Coloque o cursor no ponto apropriado no método de teste e, no menu de atalho, escolha Gerar Código para Teste de IU Codificado. O novo código será inserido nesse ponto.

  7. Edite os detalhes das ações de teste e as asserções.

    Abra UIMap. UITest. Esse arquivo é aberto no Editor de teste de interface do usuário codificado, no qual você pode editar qualquer sequência de ações registradas, bem como editar suas asserções.

    Editor de Testes de Interface de Usuário Codificada

    Para obter mais informações, confira Editar testes de IU codificados usando o Editor de Teste de IU Codificado.

  8. Execute o teste.

    Use o Gerenciador de Testes ou abra o menu de atalho no método de teste e, em seguida, escolha Executar Testes. Para obter mais informações sobre como executar testes, consulte executar testes de unidade com o Test Explorer e Opções adicionais para executar testes de interface do usuário codificados na seção What ' s Next? no final deste tópico.

As seções restantes neste tópico fornecem mais detalhes sobre as etapas desse procedimento.

Para obter um exemplo mais detalhado, consulte Walkthrough: criando, editando e mantendo um teste de interface do usuário codificado. Neste passo a passo, você criará um aplicativo simples do WPF (Windows Presentation Foundation) para demonstrar como criar, editar e manter um teste de IU codificado. O passo a passo fornece soluções para corrigir os testes que foram interrompidos por vários problemas de timing e refatoração de controle.

Iniciar e parar o aplicativo em teste

Se não quiser iniciar e parar o aplicativo, o navegador ou o banco de dados separadamente para cada teste, faça um dos seguintes:

  • Se não quiser registrar as ações para iniciar o aplicativo em teste, será necessário iniciá-lo antes de escolher o ícone Registrar.

  • No final de um teste, o processo no qual o teste é executado é encerrado. Se tiver iniciado o aplicativo no teste, normalmente, o aplicativo é fechado. Se não quiser que o teste feche o aplicativo quando terminar, adicione um arquivo .runsettings à solução e usar a opção KeepExecutorAliveAfterLegacyRun. Para obter mais informações, consulte Configurar testes de unidade usando um arquivo .runsettings.

  • Adicione um método de inicialização do teste, identificado por um atributo [TestInitialize], que executa o código no início de cada método de teste. Por exemplo, você poderia iniciar o aplicativo do método TestInitialize.

  • Adicione um método de limpeza do teste, identificado por um atributo [TestCleanup], que executa o código no final de cada método de teste. Por exemplo, o método para fechar o aplicativo poderia ser chamado do método TestCleanup.

Validar as propriedades de controles de IU

Use o Construtor de Teste de Interface do Usuário Codificado para adicionar um controle de interface do usuário ao UIMap para o teste, ou gerar código para um método de validação que usa uma declaração para um controle de interface do usuário.

Para gerar asserções para seus controles de interface do usuário, escolha a ferramenta Adicionar asserções no Construtor de teste de interface do usuário codificado e arraste-a para o controle no aplicativo em teste que você deseja verificar está correto. Quando a caixa contornar o controle, solte o mouse. O código da classe de controle é criado imediatamente no arquivo UIMap.Designer.cs.

Elemento de destino do teste de IU codificado

Agora, as propriedades desse controle serão listadas na caixa de diálogo Adicionar Asserções.

Outra maneira de navegar até um determinado controle é escolhendo a seta (<<) para expandir a exibição do Mapa de Controles de interface do usuário. Para encontrar um controle pai, irmão ou filho, é possível clicar em qualquer lugar no mapa e usar as telas de direção para navegar pela árvore.

Propriedades de teste de IU codificado

Dica

Se você não vir nenhuma propriedade quando selecionar um controle em seu aplicativo ou não vir o controle no mapa de controle de interface do usuário, verifique se o controle tem uma ID exclusiva no código do aplicativo. A ID exclusiva pode ser um atributo de ID HTML ou um UId do WPF.

Depois, abra o menu de atalho na propriedade do controle de interface do usuário que você deseja verificar e aponte para Adicionar Asserção. Na caixa de diálogo Adicionar Asserção, selecione o Comparador da asserção, por exemplo, AreEqual e digite o valor da asserção em Valor de Comparação.

Asserções do teste de IU codificado

Quando tiver adicionado todas as asserções do teste, escolha OK.

Para gerar o código das asserções e adicionar o controle ao mapa de interface do usuário, escolha o ícone Gerar Código. Digite um nome para o método de teste de IU codificado e uma descrição para o método, que serão adicionados como comentários para ele. Escolha Adicionar e Gerar. Em seguida, escolha o ícone Fechar para fechar o Construtor de Teste de IU Codificado. Isso gera um código semelhante ao código a seguir. Por exemplo, se o nome inserido for AssertForAddTwoNumbers, o código terá a aparência deste exemplo:

  • Adiciona uma chamada ao método de asserção AssertForAddTwoNumbers para o método de teste no arquivo de teste de IU codificado:

    [TestMethod]
    public void CodedUITestMethod1()
    {
        this.UIMap.AddTwoNumbers();
        this.UIMap.AssertForAddTwoNumbers();
    }
    

    É possível editar esse arquivo para alterar a ordem das etapas e das asserções ou criar novos métodos de teste. Para adicionar mais código, coloque o cursor no método de teste e, no menu de atalho, escolha Gerar Código para Teste de IU Codificado.

  • Adiciona um método chamado AssertForAddTwoNumbers ao seu mapa de interface do usuário (UIMap. UITest). Esse arquivo é aberto no Editor de teste de interface do usuário codificado, no qual você pode editar as asserções.

    Editar asserção usando o Editor de Teste de IU Codificado

    Para obter mais informações, consulte Editar testes de interface do usuário codificados usando o editor de teste de interface do usuário codificado.

    Você também pode exibir o código gerado do método de asserção em UIMap.designer.cs. Porém, você não deve editar esse arquivo. Se você quiser criar uma versão adaptada do código, copie os métodos para outro arquivo, como UIMap.cs, renomeie os métodos e edite-os lá.

    public void AssertForAddTwoNumbers()
    {
        ...
    }
    

Selecionar um controle oculto usando o teclado

Se o controle que você deseja selecionar perde o foco e desaparece quando você seleciona a ferramenta Adicionar asserções do Construtor de teste de interface do usuário codificado:

Às vezes, ao adicionar controles e validar suas propriedades, talvez você precise usar o teclado. Por exemplo, quando você tentar gravar um teste de IU codificado que usa um controle de menu de clique com o botão direito do mouse, a lista de itens de menu no controle perderá o foco e desaparecerá se você tentar selecionar a ferramenta Adicionar Declarações no Construtor de Teste de IU Codificado. Isso é mostrado na ilustração a seguir, em que o menu de clique com o botão direito do mouse no Internet Explorer perde o foco e desaparece quando você tenta selecioná-lo com a ferramenta Adicionar Declarações.

Captura de tela mostrando a ferramenta Adicionar asserções no construtor de teste de interface do usuário codificado sobrepondo o menu de atalho do Internet Explorer.

Para usar o teclado e selecionar um controle de interface de usuário, focalize o controle usando o mouse. Em seguida, mantenha as teclas Ctrl e I pressionadas simultaneamente. Solte as teclas. O controle é registrado pelo Construtor de Teste de IU Codificado.

Registrar manualmente passagens do mouse

Se não conseguir registrar uma passagem do mouse sobre um controle:

Em algumas circunstâncias, um determinado controle usado em um teste de IU codificado pode exigir que você use o teclado para registrar manualmente os eventos de passagem do mouse. Por exemplo, quando você testa um aplicativo do Windows Form ou do Windows Presentation Foundation (WPF), talvez haja código personalizado. Ou talvez haja um comportamento especial definido para a passagem do mouse sobre um controle, como a expansão de um nó de árvore quando um usuário o focaliza. Para testar circunstâncias como essas, você precisa notificar manualmente o Construtor de teste de interface do usuário codificado que está passando o mouse sobre o controle pressionando as teclas de teclado predefinidas.

Ao realizar o teste de IU codificado, focalize o controle. Em seguida, pressione e segure a tecla CTRL, enquanto pressiona e pressiona as teclas Shift e R no teclado. Solte as teclas. Um evento de passagem do mouse é gravado pelo Construtor de Teste de IU Codificado.

Captura de tela da barra de comandos do construtor de teste de IU codificado com o ícone de pausa selecionado. Uma janela de dica de ferramenta mostra o local de um evento de foco do mouse.

Depois que você gerar o método de teste, um código semelhante ao seguinte exemplo será adicionado ao arquivo UIMap.Designer.cs:

// Mouse hover '1' label at (87, 9)
Mouse.Hover(uIItem1Text, new Point(87, 9));

Configurar atribuições de teclado de passagem do mouse

Se a atribuição de tecla para capturar eventos de passagem do mouse estiver sendo usada em outro lugar do ambiente:

Se necessário, a atribuição de teclado padrão do Ctrl + Shift + R que é usada para aplicar eventos de foco do mouse em seus testes de interface do usuário codificados pode ser configurada para usar chaves diferentes.

Aviso

Você não deve alterar as atribuições de teclado para eventos de passagem do mouse em circunstâncias comuns. Tenha cuidado ao definir a atribuição de teclado. A opção talvez já esteja em uso em outro lugar dentro do Visual Studio ou no aplicativo que está sendo testado.

Para alterar as atribuições de teclado, modifique o seguinte arquivo de configuração:

%ProgramFiles(x86)%\Microsoft Visual Studio\2017\Enterprise\Common7\IDE\CodedUITestBuilder.exe.config

No arquivo de configuração, altere os valores das teclas HoverKeyModifier e HoverKey para modificar as atribuições de teclado:

<!-- Begin : Background Recorder Settings -->
<!-- HoverKey to use. -->
<add key="HoverKeyModifier" value="Control, Shift"/>
<add key="HoverKey" value="R"/>

Definir passagens do mouse implícitas para o navegador da Web

Se tiver problemas para registrar passagens do mouse em um site:

Em muitos sites, quando você focaliza um determinado controle, ele expande para mostrar detalhes adicionais. Geralmente, eles parecem menus em aplicativos da área de trabalho. Como esse é um padrão comum, os testes de IU codificados permitem passagens do mouse implícitas na navegação na Web. Por exemplo, se você registrar passagens do mouse no Internet Explorer, será acionado um evento. Esses eventos podem acarretar o registro de passagens redundantes do mouse. Por isso, as passagens do mouse implícitas são registradas com ContinueOnError definido como true no arquivo de configuração de teste de interface do usuário. Isso permite que a reprodução continue em caso de falha em um evento de passagem do mouse.

Para permitir o registro de passagens do mouse implícitas em um navegador da Web, abra o arquivo de configuração:

%ProgramFiles(x86)%\Microsoft Visual Studio\2017\Enterprise\Common7\IDE\CodedUITestBuilder.exe.config

Verifique se o arquivo de configuração está com a chave RecordImplicitiHovers definida para um valor de true, como mostrado no exemplo a seguir:

<!--Use this to enable/disable recording of implicit hovers.-->
<add key="RecordImplicitHover" value="true"/>

Personalizar o teste de IU codificado

Depois de criar o teste de IU codificado, você poderá editá-lo usando qualquer uma destas ferramentas no Visual Studio:

O código gerado

Quando você escolhe Gerar Código, diversas partes do código são criadas:

  • Uma linha no método de teste.

    [CodedUITest]
    public class CodedUITest1
    { ...
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          // To generate more code for this test, select
          // "Generate Code" from the shortcut menu.      }
    }
    

    É possível clicar com o botão direito do mouse nesse método para adicionar mais ações registradas e verificações. Também é possível editá-lo para estender ou modificar o código. Por exemplo, você poderia embutir parte do código em um loop.

    Também é possível adicionar novos métodos de teste e adicionar código a eles da mesma forma. Cada método de teste deve ter o atributo [TestMethod].

  • Um método em UIMap.uitest.

    Esse método inclui os detalhes das ações registradas ou o valor verificado por você. Você pode editar esse código abrindo UIMap. UITest. Ele é aberto em um editor especializado, no qual é possível excluir ou refatorar as ações registradas.

    Exiba também o método gerado em UIMap.Designer.cs. Esse método realiza as ações registradas quando você executa o teste.

    // File: UIMap.Designer.cs
    public partial class UIMap
    {
      /// <summary>
      /// Add two numbers
      /// </summary>
      public void AddTwoNumbers()
      { ...   }
    }
    

    Aviso

    Você não deve editar esse arquivo, porque ele será registrado quando mais testes forem criados.

    É possível criar versões adaptadas desses métodos copiando-os em UIMap.cs. Por exemplo, você poderia criar uma versão parametrizada que seria chamada a partir de um método de teste:

    // File: UIMap.cs
    public partial class UIMap // Same partial class
    {
      /// <summary>
      /// Add two numbers - parameterized version
      /// </summary>
      public void AddTwoNumbers(int firstNumber, int secondNumber)
      { ...   // Code modified to use parameters.
      }
    }
    
  • Declarações em UIMap.uitest.

    Essas declarações representam os controles de interface de usuário do aplicativo usados pelo teste. Elas são usadas pelo código gerado para operar os controles e acessar suas propriedades.

    Também será possível usá-las para gravar seu próprio código. Por exemplo, é possível fazer o método de teste escolher um hiperlink em um aplicativo Web, digitar um valor em uma caixa de texto ou ramificar e utilizar ações de testes diferentes com base no valor de um campo.

    É possível adicionar vários testes de IU codificados e vários objetos e arquivos de mapa de IU para facilitar os testes de um aplicativo grande. Para obter mais informações, confira Testar um aplicativo grande com vários Mapas de Interface do Usuário.

Para obter mais informações sobre o código gerado, consulte a anatomia de um teste de interface do usuário codificado.

Propriedades e ações de controle de IU codificado

Quando você trabalha com controles de teste de IU em testes de IU codificados, eles são separados em duas partes: ações e propriedades.

  • A primeira parte consiste em ações, que é possível realizar em controles de teste de IU. Por exemplo, os testes de IU codificados podem simular cliques do mouse em um controle de teste de IU ou simular teclas pressionadas no teclado para afetar um controle de teste de IU.

  • A segunda parte consiste em permitir que você obtenha e defina as propriedades em um controle de teste de IU. Por exemplo, os testes de IU codificados podem obter a contagem de itens em um ListBox ou definir um CheckBox no estado selecionado.

Acessar ações do controle de teste de IU

Para realizar ações em controles de teste de IU, como cliques do mouse ou ações de teclado, use os métodos nas classes Mouse e Keyboard:

  • Para realizar uma ação orientada pelo mouse, como um clique do mouse em um controle de teste de IU, use Click.

    Mouse.Click(buttonCancel);

  • Para realizar uma ação orientada pelo teclado, como digitar em um controle de edição, use SendKeys.

    Keyboard.SendKeys(textBoxDestination, @"C:\Temp\Output.txt");

Acessar propriedades do controle de teste de IU

Para obter e definir valores de propriedade específicas de controle de interface de usuário, é possível obter e definir diretamente os valores como as propriedades de um controle ou usar os métodos Microsoft.VisualStudio.TestTools.UITesting.UITestControl.GetProperty e Microsoft.VisualStudio.TestTools.UITesting.UITestControl.SetProperty com o nome da propriedade específica que você deseja obter ou definir.

GetProperty retorna um objeto, que pode ser convertido no Type apropriado. SetProperty aceita um objeto para o valor da propriedade.

Para obter ou definir propriedades de controles de teste de IU diretamente

Com controles que derivam de UITestControl, como HtmlList ou WinComboBox, você pode obter ou definir os valores de propriedade diretamente. O código a seguir mostra alguns exemplos:

int i = myHtmlList.ItemCount;
myWinCheckBox.Checked = true;

Para obter propriedades de controles de teste de IU

  • Para obter um valor de propriedade de um controle, use GetProperty.

  • Para especificar a propriedade de controle a ser obtida, use a cadeia de caracteres apropriada da classe PropertyNames em cada controle como parâmetro para GetProperty.

  • GetProperty retorna o tipo de dados apropriado, mas esse valor retornado é convertido como um Object. Em seguida, o Object de retorno deve ser convertido como tipo apropriado.

    Exemplo:

    int i = (int)GetProperty(myHtmlList.PropertyNames.ItemCount);

Para definir propriedades para controles de teste de IU

  • Para obter uma propriedade em um controle, use SetProperty.

  • Para especificar a propriedade do controle a ser definida, use a cadeia de caracteres apropriada da classe PropertyNames como primeiro parâmetro para SetProperty, com o valor da propriedade como segundo parâmetro.

    Exemplo:

    SetProperty(myWinCheckBox.PropertyNames.Checked, true);

Depurar

Você pode analisar testes de IU codificados usando logs de teste de IU codificado. Os logs de teste de IU codificado filtram e registram informações importantes sobre as execuções de teste de IU codificado. O formato dos logs permite depurar rapidamente os problemas. Para obter mais informações, confira Analisar testes de IU codificados usando logs de teste de IU codificado.

E agora?

Opções adicionais para executar testes de IU codificados: Você pode executar testes de interface do usuário codificados diretamente do Visual Studio, conforme descrito anteriormente neste tópico. Além disso, você pode executar testes automatizados de interface do usuário no Microsoft Test Manager ou usando o Azure Pipelines. Quando são automatizados, os testes de IU codificados precisam interagir com a área de trabalho quando executados, diferentemente de outros testes automatizados.

Opções adicionais para executar testes de IU codificados: Você pode executar testes de interface do usuário codificados diretamente do Visual Studio, conforme descrito anteriormente neste tópico. Além disso, você pode executar testes de interface do usuário automatizados usando Azure Pipelines. Quando são automatizados, os testes de IU codificados precisam interagir com a área de trabalho quando executados, diferentemente de outros testes automatizados.

Adicionando suporte para controles personalizados: A estrutura de teste de interface do usuário codificada não oferece suporte a todas as interfaces do usuário possíveis e pode não dar suporte à interface do usuário que você deseja testar. Por exemplo, você não pode criar imediatamente um teste de IU codificado para a IU do Microsoft Excel. Porém, você pode criar uma extensão para o framework de teste de IU codificado que é compatível com um controle personalizado.

Os testes de IU codificados costumam ser usados para automatizar testes manuais. Para obter mais informações sobre testes automatizados, confira Ferramentas de teste no Visual Studio.

Consulte também