Teste aplicações WinUI construídas com o SDK de Aplicações Windows

Neste tópico, fornecemos algumas recomendações sobre como testar e validar funcionalidades em aplicações criadas com as funcionalidades SDK de Aplicações Windows utilizando WinUI 3 funcionalidades de interface de utilizador (UI). Os testes são uma parte essencial do processo de desenvolvimento de aplicações — ajudam-no a detetar bugs precocemente, a manter a qualidade do código e a garantir uma experiência de utilizador fiável à medida que a sua aplicação evolui. Ao incorporar testes unitários no seu fluxo de trabalho, pode refatorar código com confiança, adicionar novas funcionalidades e lançar atualizações sabendo que a funcionalidade existente continua a funcionar como esperado.

Tutorial: Crie um projeto de teste unitário WinUI 3.

A maioria dos tipos de objetos nos namespaces Microsoft.UI.Xaml deve ser usada a partir de um thread UI num processo de aplicação XAML. (Para detalhes sobre o teste de aplicações criadas com SDK de Aplicações Windows que não usam o WinUI 3, veja a secção seguinte, Testar funcionalidades não-WinUI.)

Neste tutorial, aprenderás como:

Pré-requisitos

Tens de ter o Visual Studio instalado e configurado para o desenvolvimento do WinUI. Veja Início Rápido: Configure o seu ambiente e crie um projeto WinUI 3.

Criar um projeto de Aplicação de Testes Unitários de WinUI

Para começar, crie um projeto de teste unitário. O tipo de projeto vem com todos os arquivos de modelo que você precisa.

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

   

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

   

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

4. Selecione Criar.

Executar testes com o Explorador de Testes

Quando crias o projeto de teste, os teus testes aparecem no Explorador de Testes, que é usado para executar os testes unitários. Também pode agrupar testes em categorias, filtrar a lista de testes, criar, guardar e executar listas de reprodução de testes, depurar testes unitários e (no Visual Studio Enterprise) analisar a cobertura de código.

O ficheiro UnitTests.cs contém o código-fonte dos testes unitários usados pelo Explorador de Testes. Por padrão, os testes básicos de amostra apresentados 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 ainda não o fizeste, constrói a tua solução. Isto permitirá ao Visual Studio "descobrir" todos os testes disponíveis.

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

   

3. Ver testes. Na janela do Explorador de Testes, expanda todos os nós (apenas os testes de amostra estarão presentes neste ponto).

   

4. Faz testes.

   • Clique com o botão direito nos nós de teste individuais e selecione Executar.
   • Selecione um teste e pressione o botão Play ou pressione Ctrl + R, T.
   • Prime no botão Executar Todos os Testes na Vista ou prima Ctrl + R, V.

   

5. Analisar os resultados Após a conclusão dos testes, os resultados são mostrados na janela do Explorador de Testes .

   

Adicionar um projeto da Biblioteca de Turmas para testes

6. Adicione um novo projeto à solução de testes unitários. No Explorador de Soluções, clique com o botão direito na solução e selecione Adicionar -> Novo Projeto....

   

7. Para este exemplo, adiciona um projeto de biblioteca de classes WinUI 3. Na janela do Novo Projeto, filtre por C#/Windows/WinUI e selecione WinUI Class Library.

   

8. Selecione Seguinte e introduza um nome para o projeto (neste exemplo usamos WinUIClassLibrary1) e pressione em Criar.

   

9. Adicione um novo UserControl ao projeto. No Explorador de Soluções, clique com o botão direito no projeto da biblioteca de classes WinUI 3 que acabou de adicionar e selecione Add -> New Item no menu contextual.

   

10. Na janela Adicionar Novo Item , selecione o nó WinUI na lista de itens instalados e depois escolha Controlo do Utilizador nos resultados. Nomeie o controlo UserControl1.

    

11. Abra o ficheiro de code-behind UserControl1.xaml.cs. Para este exemplo, adicionamos um novo método público chamado GetSeven que simplesmente devolve um inteiro.

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

12. Defina o projeto Biblioteca de Classes WinUI 3 como uma dependência do projeto de teste unitário para permitir a utilização de tipos do projeto de biblioteca de classes WinUI 3. Em Explorador de Soluções, no projeto da biblioteca de classes, clique com o botão direito em Dependências e selecione Adicionar Referência do Projeto.

    

    Selecione o WinUIClassLibrary1 item da lista de Projetos .

    

13. Crie um novo método de teste em UnitTests.cs. Como este caso de teste requer um thread de interface XAML para ser 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());
    }
    

    Este novo método de teste aparece agora no Explorador de Testes como um dos seus testes unitários.

    

14. Faz testes.

• Clique com o botão direito no novo nó de teste e selecione Executar.
• Selecione o novo teste e pressione o botão Play ou pressione Ctrl + R, T.
• Prime no botão Executar Todos os Testes na Vista ou prima Ctrl + R, V.

Testar funcionalidades não-WinUI

Em muitos casos, um aplicativo inclui funcionalidades que não dependem dos tipos Microsoft.UI.Xaml, mas ainda precisam de testes. Existem várias ferramentas disponíveis para testar código .NET, incluindo MSTest, NUnit e xUnit. Para mais detalhes sobre testes .NET aplicações, consulte Testing in .NET.

No Visual Studio, pode criar um novo projeto para qualquer uma destas ferramentas de teste clicando com o botão direito da sua solução em Explorador de Soluções, selecionando Add -> New Project no menu contextual, escolhendo C# no seletor All languages/Windows do seletor Todas as línguas seletor/Test do seletor Todos os tipos de projeto, e depois escolher a ferramenta de teste apropriada da lista (MSTest Test Project, NUnit Test Project ou xUnit Test Project).

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

1. Atualize o TargetFramework no arquivo .csproj do seu projeto de teste. Este valor deve corresponder ao TargetFramework no projeto WinUI 3. Por padrão, os projetos MSTest, NUnit e xUnit apontam para toda a gama de plataformas suportadas pelo .NET, mas um projeto WinUI 3 suporta apenas Windows e tem uma estrutura-alvo mais específica.

   Por exemplo, se o objetivo é .NET 8, atualize o TargetFramework do projeto de teste unitário 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 ficheiro PropertyGroup .csproj do seu projeto de teste para garantir que o teste carrega o runtime do SDK de Aplicações Windows: <WindowsAppSdkBootstrapInitialize>true</WindowsAppSdkBootstrapInitialize>

4. Certifique-se de que o runtime do SDK de Aplicações Windows está instalado na máquina que executa o teste. Para mais informações sobre a implantação do SDK de Aplicações Windows, consulte o guia de implantação do SDK de Aplicações Windows para aplicações dependentes do framework empacotadas com localização externa (ou não empacotadas).

Automação de testes UI

Para testes de ponta a ponta da interface da sua aplicação, pode usar ferramentas automatizadas de teste de interface que interagem com a sua aplicação da mesma forma que um utilizador o faria — clicando em botões, introduzindo texto e verificando o estado visual.

Appium com WinAppDriver

O WinAppDriver foi a ferramenta original da Microsoft para testes de automação da interface do Windows, mas já não está em desenvolvimento ativo. O sucessor recomendado é o Appium com o plugin Windows Application Driver (appium-windows-driver). A Appium utiliza o mesmo protocolo WebDriver e suporta Windows aplicações de ambiente de trabalho através do framework Windows Automatização da Interface de Utilizador.

Para configurar o Appium para uma aplicação de ambiente de trabalho WinUI 3:

1. Instalar 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 aparecer windows como instalado)
4. Inicie o servidor Appium: appium
5. Escrever testes usando uma biblioteca cliente WebDriver (disponível para C#, Python, Java e JavaScript).

Informações de Acessibilidade e Automação da IU

O Accessibility Insights para Windows ajuda-o a inspecionar e validar a árvore de Automatização da Interface de Utilizador da sua aplicação. Os elementos expostos através da Automatização da Interface de Utilizador são os mesmos com que as ferramentas de teste automatizadas interagem. Garantir que a sua aplicação tem uma árvore de automação bem estruturada melhora tanto a acessibilidade como a capacidade de testabilidade.

Microsoft Playwright (IU da Web no WebView2)

Se a sua aplicação usar o WebView2 para conteúdos web, pode usar o Microsoft Playwright para testar as partes web. O Playwright suporta testes automatizados de navegador e pode ligar-se a instâncias 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 detetam bugs, problemas de segurança e problemas de qualidade de código antes da execução. Integre estes no seu fluxo de trabalho de desenvolvimento e pipelines de CI para garantir uma qualidade consistente.

Analisadores .NET (Roslyn)

Os projetos .NET incluem analisadores Roslyn incorporados que verificam a correção, desempenho, fiabilidade e questões de segurança. Para ativar todas as regras recomendadas no seu projeto:

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

Pode configurar severidades de regras num .editorconfig ficheiro ou usando <NoWarn> no seu ficheiro de projeto. Para obter mais informações, consulte Visão geral da análise do código-fonte do .NET.

Análise estática em C++ (/analyze)

Para projetos C++ do SDK de Aplicações Windows e Win32, ative 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 Centrais em C++ aplica as melhores práticas modernas em C++. Para padrões de utilização da API Win32, as anotações SAL e o sinalizador /analyze detetam problemas comuns relacionados com o tempo de vida, os buffers e a concorrência.

Integração CI

Adicione análise estática ao seu fluxo de trabalho de CI para que as verificações de qualidade do código corram em cada pull request. Num fluxo de trabalho do GitHub Actions:

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

Para projetos em C++ usando MSBuild:

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

Telemetria e reporte de falhas

Recolher dados de telemetria e falhas em produção ajuda-o a perceber como a sua aplicação se comporta no mundo real, identificar regressões e priorizar correções.

Application Insights

O Aplicação Azure Insights fornece relatórios de falhas, monitorização de desempenho e análises de utilização para aplicações de ambiente de trabalho. Para o adicionar a um projeto do SDK de Aplicações Windows:

1. Instale o pacote NuGet: Microsoft.ApplicationInsights
2. Inicialize o TelemetryClient ao iniciar a sua aplicação com a sua cadeia de ligação
3. Acompanhar exceções, eventos e visualizações de página

Para instruções detalhadas de configuração, consulte Application Insights para aplicações de consola e desktop .NET.

OpenTelemetry

A OpenTelemetry é uma norma neutra em relação ao fornecedor para recolher registos, métricas e traços distribuídos. O SDK .NET OpenTelemetry integra-se com o Azure Monitor e outros backends.

Instale os pacotes necessários:

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

Depois configura o fornecedor de traçadores:

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

A OpenTelemetry é a abordagem recomendada para novos projetos que necessitam de suporte multi-backend ou rastreamento distribuído. O Application Insights continua a ser uma boa escolha se usar exclusivamente o Azure Monitor e quiser dashboards turnkey.

Relatórios de Erros do Windows (WER)

Para a recolha nativa de falhas, o Windows Error Reporting captura automaticamente os crash dumps quando a sua aplicação termina inesperadamente. As aplicações empacotadas (MSIX) passam a ter dados sobre falhas disponibilizados nos relatórios de qualidade do Partner Center. Para aplicações de linha de negócio (LOB), é possível configurar a recolha local de dumps do WER para guardar minidumps para análise local.

Recursos adicionais

• Noções básicas de teste de unidade
• Ferramentas de teste em Visual Studio
• Integração contínua para aplicações WinUI
• Visão geral da análise do código-fonte .NET
• Análise de código C++
• Azure Monitor Application Insights
• OpenTelemetry .NET SDK