Testar aplicativos WinUI criados com o SDK do Aplicativo Windows

Neste tópico, fornecemos algumas recomendações sobre como testar e validar a funcionalidade em aplicativos criados com os recursos SDK do Aplicativo Windows usando WinUI 3 recursos de interface do usuário (interface do usuário). O teste é uma parte essencial do processo de desenvolvimento de aplicativos, ele ajuda você a capturar bugs antecipadamente, manter a qualidade do código e garantir uma experiência confiável do usuário à medida que seu aplicativo evolui. Ao incorporar testes de unidade em seu fluxo de trabalho, você pode refatorar o código com confiança, adicionar novos recursos e enviar atualizações sabendo que a funcionalidade existente continua funcionando conforme o esperado.

Tutorial: Criar um projeto de teste de unidade do WinUI 3.

A maioria dos tipos de objeto nos namespaces Microsoft.UI.Xaml deve ser usada de um thread de interface do usuário em um processo de aplicativo XAML. (Para obter detalhes sobre como testar aplicativos criados com SDK do Aplicativo Windows que não usam o WinUI 3, consulte a seção a seguir, Testing non-WinUI functionality.)

Observação

Recomendamos que você refatore qualquer código a ser testado retirando-o do projeto de aplicativo principal e colocando-o em um projeto de biblioteca. O projeto de aplicativo e o projeto de teste de unidade podem fazer referência a esse projeto de biblioteca. Esta seção descreve como criar testes de unidade para aplicativos WinUI 3 em Visual Studio usando os modelos internos de projeto de teste de unidade.

Observação

O aplicativo de teste de unidade descrito aqui é escrito no contexto de um aplicativo WinUI 3. Isso é necessário para todos os testes que executam o código que exige o runtime XAML. Esse projeto criará um Thread de Interface do Usuário XAML e executará os testes.

Neste tutorial, você aprenderá como:

  • Crie um projeto WinUI Unit Test App no Visual Studio.
  • Use Visual Studio Test Explorer.
  • Adicione um projeto da Biblioteca de Classes do WinUI para teste.
  • Execute testes com o Gerenciador de Testes do Visual Studio.

Pré-requisitos

Você deve ter Visual Studio instalado e configurado para o desenvolvimento do WinUI. Veja o início rápido: configure seu ambiente e crie um projeto WinUI 3.

Criar um projeto de aplicativo de teste de unidade do WinUI

Para começar, crie um projeto de teste de unidade. O tipo de projeto vem com todos os arquivos de modelo necessários.

  1. Abra Visual Studio e selecione Criar um novo projeto na janela Iniciar.

    Screenshot da janela inicial do Visual Studio.

  2. Na janela Criar um novo projeto, filtre projetos para C#Windows e WinUI, selecione o modelo WinUI Unit Test App e selecione Next

    Screenshot da janela

  3. [Opcional] Na janela Configurar seu novo projeto, altere o Nome do projeto, Nome da solução (desmarque Inserir solução e projeto no mesmo diretório) e Local do projeto.

  4. Selecione Criar.

Executar testes com o Gerenciador de Testes

Quando você cria o projeto de teste, seus testes aparecem no Gerenciador de Testes, que é usado para executar os testes de unidade. Você também pode agrupar testes em categorias, filtrar a lista de testes, criar, salvar e executar playlists de testes, depurar testes de unidade e (em Visual Studio Enterprise) analisar a cobertura de código.

O arquivo UnitTests.cs contém o código-fonte para os testes de unidade usados pelo Gerenciador de Testes. Por padrão, os testes de exemplo básicos mostrados aqui são criados automaticamente:

namespace WinUITest1
{
   [TestClass]
   public class UnitTest1
   {
      [TestMethod]
      public void TestMethod1()
      {
         Assert.AreEqual(0, 0);
      }

      // Use the UITestMethod attribute for tests that need to run on the UI thread.
      [UITestMethod]
      public void TestMethod2()
      {
         var grid = new Grid();
         Assert.AreEqual(0, grid.MinWidth);
      }
   }
}

  1. Se você ainda não fez isso, crie sua solução. Isso permitirá que Visual Studio "descubra" todos os testes disponíveis.

  2. Abra o Gerenciador de Testes. Se não estiver visível, abra o menu Teste e escolha Gerenciador de Testes (ou pressione Ctrl + E, T).

    Captura de tela do menu Test no Visual Studio.

  3. Veja os testes. Na janela Gerenciador de Testes , expanda todos os nós (somente os testes de exemplo estarão presentes neste ponto).

    Screenshot da janela do Gerenciador de Testes em Visual Studio mostrando os testes de exemplo padrão.

  4. Executar testes.

    • Clique com o botão direito do mouse em nós de teste individuais e selecione Executar.
    • Selecione um teste e pressione o botão Reproduzir ou pressione Ctrl + R, T.
    • Pressione o botão Executar todos os testes na exibição ou pressione Ctrl + R, V.

    Screenshot da janela do Gerenciador de Testes em Visual Studio mostrando o menu de contexto de teste com o comando Executar realçado.

  5. Examinar os resultados. Após a conclusão dos testes, os resultados são mostrados na janela Gerenciador de Testes.

    Screenshot da janela do Gerenciador de Testes em Visual Studio mostrando os resultados da execução de teste.

Adicionar um projeto da Biblioteca de Classes para teste

  1. Adicione um novo projeto à solução de teste de unidade. No Gerenciador de Soluções, clique com o botão direito do mouse na solução e selecione Add -> Novo Projeto... .

    Screenshot do menu de contexto da solução com Adicionar/Novo Projeto realçado no Visual Studio.

  2. Para este exemplo, adicione um projeto de biblioteca de classes do WinUI 3. Na janela Novo Projeto, filtre em C#/Windows/WinUI e selecione Biblioteca de ClassesWinUI.

    Captura de tela da janela Novo Projeto com a Biblioteca de Classes WinUI destacada no Visual Studio.

  3. Selecione Avançar e insira um nome para o projeto (para este exemplo que usamos WinUIClassLibrary1) e pressione Criar.

    Captura de tela do novo projeto 'Biblioteca de Classes WinUI' destacado no Gerenciador de Soluções e no arquivo Class1.cs aberto no editor de código.

  4. Adicione um novo UserControl ao projeto. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto de biblioteca de classes do WinUI 3 que você acabou de adicionar e selecione Add -> Novo Item no menu de contexto.

    Screenshot do menu de contexto da solução com Adicionar/Novo Item realçado no Visual Studio.

  5. Na janela Adicionar Novo Item , selecione o nó WinUI na lista de itens instalados e escolha Controle de Usuário nos resultados. Nomeie o controle UserControl1.

    Captura de tela da janela

  6. Abra o arquivo code-behind UserControl1.xaml.cs. Para este exemplo, adicionamos um novo método público chamado GetSeven que simplesmente retorna um inteiro.

    namespace WinUIClassLibrary1
{
  public sealed partial class UserControl1 : UserControl
  {
     public UserControl1()
     {
         this.InitializeComponent();
     }

     public int GetSeven()
     {
         return 7;
     }
  }
}

  7. Defina o projeto da Biblioteca de Classes do WinUI 3 como uma dependência do projeto de teste de unidade para habilitar o uso de tipos do projeto de biblioteca de classes do WinUI 3. Em Gerenciador de Soluções, no projeto da biblioteca de classes, clique com o botão direito do mouse em Dependencies e selecione Add Project Reference.

    Captura de tela do menu de contexto de Dependências com Adicionar Referência de Projeto realçado no Visual Studio.

    Selecione o item WinUIClassLibrary1 na lista de Projetos.

    Captura de tela da caixa de diálogo Gerenciador de Referências com o projeto 'WinUIClassLibrary1' selecionado.

  8. Crie um novo método de teste no UnitTests.cs. Como esse caso de teste requer que um Thread de Interface do Usuário XAML seja executado, marque-o com o [UITestMethod] atributo em vez do atributo padrão [TestMethod] .

    [UITestMethod]
public void TestUserControl1()
{
   WinUIClassLibrary1.UserControl1 userControl1 = new WinUIClassLibrary1.UserControl1();
   Assert.AreEqual(7, userControl1.GetSeven());
}

    Esse novo método de teste agora aparece no Gerenciador de Testes como um dos seus testes de unidade.

    Screenshot da janela do Gerenciador de Testes em Visual Studio mostrando os testes de exemplo padrão com o novo teste de unidade.

  9. Executar testes.

  • Clique com o botão direito do mouse no nó do novo teste e selecione Executar.
  • Selecione o novo teste e pressione o botão Executar ou pressione Ctrl + R, T.
  • Pressione o botão Executar todos os testes na exibição ou pressione Ctrl + R, V.

Screenshot da janela do Gerenciador de Testes em Visual Studio mostrando uma execução de teste concluída dos testes de exemplo padrão e do novo teste de unidade.

Testar funcionalidade fora do WinUI

Em muitos casos, um aplicativo inclui funcionalidade que não depende dos tipos Microsoft.UI.Xaml, mas ainda precisa de testes. Várias ferramentas estão disponíveis para testar .NET código, incluindo MSTest, NUnit e xUnit. Para obter mais detalhes sobre como testar aplicativos .NET, consulte Testing no .NET.

Em Visual Studio, você pode criar um novo projeto para qualquer uma dessas ferramentas de teste clicando com o botão direito do mouse em sua solução no Gerenciador de Soluções, selecionando Adicionar -> Novo Projeto no menu de contexto, escolhendo C# no seletor de Todos os idiomas/Windows no seletor de Todos os idiomas/Teste no seletor de Todos os tipos de projeto, e, em seguida, escolhendo a ferramenta de teste apropriada na lista (projeto de teste MSTest, projeto de teste NUnit ou projeto de teste xUnit).

Ao criar um novo projeto MSTest, NUnit ou xUnit que faça referência a um projeto WinUI 3, você deve:

  1. Atualize o TargetFramework no arquivo .csproj do seu projeto de teste. Esse valor deve corresponder ao TargetFramework do projeto WinUI 3. Por padrão, os projetos MSTest, NUnit e xUnit têm como destino toda a gama de plataformas compatíveis com .NET, mas um projeto WinUI 3 dá suporte apenas a Windows e tem um TargetFramework mais específico.

    Por exemplo, se você estiver direcionando o .NET 8, atualize o TargetFramework do projeto de teste de unidade de <TargetFramework>net8.0</TargetFramework> para <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>.

  2. Atualize os RuntimeIdentifiers em seu projeto de teste.

    <RuntimeIdentifiers Condition="$([MSBuild]::GetTargetFrameworkVersion('$(TargetFramework)')) &gt;= 8">win-x86;win-x64;win-arm64</RuntimeIdentifiers>

    <RuntimeIdentifiers Condition="$([MSBuild]::GetTargetFrameworkVersion('$(TargetFramework)')) &lt; 8">win10-x86;win10-x64;win10-arm64</RuntimeIdentifiers>

  3. Adicione a seguinte propriedade ao PropertyGroup no arquivo .csproj do projeto de teste para garantir que o teste carregue o SDK do Aplicativo Windows runtime: <WindowsAppSdkBootstrapInitialize>true</WindowsAppSdkBootstrapInitialize>

  4. Verifique se o SDK do Aplicativo Windows runtime está instalado no computador que executa o teste. Para obter mais informações sobre a implantação do SDK do Aplicativo Windows, consulte o Guia de Implantação do SDK do Aplicativo Windows para aplicativos dependentes de framework empacotados com local externo (ou não empacotados).

Automação de teste de interface do usuário

Para testes de ponta a ponta da interface do usuário do aplicativo, você pode usar ferramentas automatizadas de teste de interface do usuário que interagem com seu aplicativo da maneira que um usuário faria: clicar em botões, inserir texto e verificar o estado visual.

Appium com WinAppDriver

O WinAppDriver foi a ferramenta original da Microsoft para testes de automação de interface do usuário no Windows, mas não está mais em desenvolvimento ativo. O sucessor recomendado é Appium com o plugin Windows Application Driver (appium-windows-driver). O Appium usa o mesmo protocolo WebDriver e oferece suporte a aplicativos de desktop do Windows por meio do framework Windows Automação da Interface do Usuário.

Para configurar o Appium para um aplicativo da área de trabalho do WinUI 3:

Observação

Essas etapas exigem Node.js (LTS recomendado).

  1. Instalar o Appium: npm install -g appium
  2. Instale o driver do Windows: appium driver install windows
  3. Verifique se o driver está instalado: appium driver list (deve ser exibido windows como instalado)
  4. Inicie o servidor Appium: appium
  5. Escreva testes usando uma biblioteca de clientes do WebDriver (disponível para C#, Python, Java e JavaScript).

Dica

Defina a app funcionalidade para a AUMID (ID do Modelo de Usuário do Aplicativo) do aplicativo para aplicativos empacotados ou o caminho executável para aplicativos não empacotados.

Insights de Acessibilidade e Automação da Interface do Usuário

O Accessibility Insights for Windows ajuda você a inspecionar e validar a árvore de Automação da Interface do Usuário do seu aplicativo. Os elementos expostos por meio de Automação da Interface do Usuário são os mesmos elementos com os quais as ferramentas de teste automatizadas interagem. Garantir que seu aplicativo tenha uma árvore de automação bem estruturada melhora a acessibilidade e a capacidade de teste.

Microsoft Dramaturgo (interface do usuário da Web no WebView2)

Se o aplicativo usa WebView2 para conteúdo web, você pode usar Microsoft Playwright para testar as partes web. O Playwright oferece suporte a testes automatizados em navegadores e pode se conectar a instâncias do WebView2 para validação de cenários de ponta a ponta.

Qualidade do código e análise estática

As ferramentas de análise estática capturam bugs, problemas de segurança e problemas de qualidade de código antes do runtime. Integre-os ao fluxo de trabalho de desenvolvimento e aos pipelines de CI para uma qualidade consistente.

analisadores de .NET (Roslyn)

Os projetos .NET incluem analisadores internos do Roslyn que detectam problemas de correção, desempenho, confiabilidade e segurança. Para habilitar todas as regras recomendadas em seu projeto:

<PropertyGroup>
  <AnalysisLevel>latest-recommended</AnalysisLevel>
  <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
</PropertyGroup>

Você pode configurar as severidades das regras em um arquivo .editorconfig ou usando o <NoWarn> no arquivo do projeto. Para obter mais informações, consulte Visão geral da análise do código-fonte do .NET.

Análise estática do C++ (/analisar)

Para projetos do SDK de Aplicativo do Windows para C++ e Win32, habilite a análise estática da Microsoft definindo /analyze nas propriedades do projeto ou no MSBuild:

<PropertyGroup>
  <EnableMicrosoftCodeAnalysis>true</EnableMicrosoftCodeAnalysis>
  <CodeAnalysisRuleSet>CppCoreCheckRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>

O Verificador de Diretrizes do C++ Core impõe as práticas recomendadas modernas do C++. Para padrões de uso da API Win32, as anotações SAL e a opção /analyze detectam problemas comuns de ciclo de vida, buffer e concorrência.

Integração de CI

Adicione análise estática ao fluxo de trabalho de CI para que as verificações de qualidade de código sejam executadas em cada solicitação de pull. Em um fluxo de trabalho GitHub Actions:

    - name: Build with analysis
      run: dotnet build --configuration Release /p:AnalysisLevel=latest-recommended /p:TreatWarningsAsErrors=true

Para projetos C++ usando o MSBuild:

    - name: Build with /analyze
      run: msbuild MySolution.sln /p:Configuration=Release /p:EnableMicrosoftCodeAnalysis=true /p:RunCodeAnalysis=true

Telemetria e relatórios de falha

Coletar dados de telemetria e falhas da produção ajuda você a entender como seu aplicativo é executado no mundo real, identificar regressões e priorizar correções.

Application Insights

Aplicativo Azure Insights fornece relatórios de falha, monitoramento de desempenho e análise de uso para aplicativos da área de trabalho. Para adicioná-lo a um projeto de SDK do Aplicativo Windows:

Observação

Você precisa de uma assinatura Azure e um recurso do Application Insights. Consulte Criar um recurso do Application Insights para obter a cadeia de conexão.

  1. Instale o pacote NuGet: Microsoft.ApplicationInsights
  2. Inicialize o TelemetryClient durante a inicialização do aplicativo com a sua cadeia de conexão
  3. Acompanhar exceções, eventos e exibições de página

Para obter instruções detalhadas de instalação, consulte o Application Insights para .NET console e aplicativos da área de trabalho.

OpenTelemetry

OpenTelemetry é um padrão independente de fornecedor para coletar logs, métricas e rastreamento distribuído. O .NET OpenTelemetry SDK se integra ao Azure Monitor e a outros backends.

Instale os pacotes necessários:

dotnet add package OpenTelemetry
dotnet add package Azure.Monitor.OpenTelemetry.Exporter

Em seguida, configure o provedor de rastreamento:

var activitySource = new System.Diagnostics.ActivitySource("MyApp");
// OpenTelemetry SDKs can listen to ActivitySource instances like this one.
using var activity = activitySource.StartActivity("Startup");
activity?.SetTag("app.version", "1.0.0");

OpenTelemetry é a abordagem recomendada para novos projetos que precisam de suporte multi-back-end ou rastreamento distribuído. O Application Insights continuará sendo uma boa opção se você usar Azure Monitor exclusivamente e quiser painéis turnkey.

Relatório de Erros do Windows (WER)

Para a coleta de falhas nativa, Windows Relatório de Erros captura automaticamente despejos de memória quando seu aplicativo é encerrado inesperadamente. Os aplicativos empacotados (MSIX) têm os dados de falha exibidos nos relatórios de qualidade do Partner Center. Para aplicativos organizacionais (LOB), você pode configurar a coleta de despejos locais do WER para salvar minidespejos para análise local.

Recursos adicionais

  • Last updated on