Criação de teste assistida por IA com GitHub Copilot (preterida)

A criação de planos de teste abrangentes para aplicativos do Power Platform pode ser demorada, especialmente para cenários complexos. Ferramentas de criação assistidas por IA, como GitHub Copilot, podem acelerar significativamente esse processo gerando modelos de teste, sugerindo casos de teste e automatizando a criação de código clichê.

Este guia explica como usar GitHub Copilot com soluções de controle do código-fonte do Power Platform para criar planos de teste do Mecanismo de Teste com eficiência.

Pré-requisitos

Antes de começar, verifique se você tem:

• Visual Studio Code instalado
• assinatura GitHub Copilot
• extensão GitHub Copilot Chat para VS Code
• Power Platform CLI instalado
• Uma solução do Power Platform controlada pela fonte

Configurando seu ambiente de criação de testes

Para maximizar a eficácia da criação de testes assistida por IA, combine estas ferramentas em um fluxo de trabalho estruturado:

1. Obtenha seus arquivos de origem
   • Clone seu ambiente do Power Platform ou a solução do controle de origem
   • Exporte e descompacte sua solução de Power Platform com arquivos usando pac solution export e pac solution unpack
2. Inicialize um repositório git para controle de versão (se ainda não tiver feito isso)
3. Crie uma pasta de teste dedicada no seu repositório de soluções
4. Abra a pasta da solução no Visual Studio Code

Usando GitHub Copilot para criação de teste

GitHub Copilot pode ajudá-lo a gerar vários componentes de teste com base em sua solução controlada pela origem. Veja como usar seus recursos de forma eficaz:

Usando documentação de amostra como contexto

O catálogo de exemplos Test Engine fornece uma fonte avançada de material de referência para GitHub Copilot. Você pode ajudar Copilot a gerar testes de maior qualidade:

• Incluindo o arquivo samples.md em seu espaço de trabalho
• Referenciando amostras específicas em seus prompts
• Fornecendo links para repositórios de GitHub de exemplo

Por exemplo, você pode:

• Abra o código do seu aplicativo e o arquivo samples.md no VS Code
• Peça ao Copilot para criar testes que sejam semelhantes ao modelo ButtonClicker ou baseados nos padrões do modelo Dataverse.
• Faça referência a recursos específicos de amostras que correspondem às suas necessidades de teste

Essa abordagem ajuda Copilot entender os padrões do Mecanismo de Teste do Power Platform e gerar testes mais precisos.

Trabalhando com GitHub Copilot no modo de agente

O GitHub Copilot Chat do Visual Studio Code oferece um modo Agent que pode ajudar a gerar testes com base em seus arquivos de solução. Esse modo permite que Copilot acessem e entendam mais profundamente o contexto do projeto.

Para usar o Modo do Agente para geração de testes:

1. No VS Code, abra o instante de conversa do GitHub Copilot (Ctrl+Shift+I)
2. Selecione Agent no seletor de modo Copilot
3. Elabore um prompt detalhado sobre o teste que você deseja criar

Exemplos de prompts para geração de teste

Tente usar prompts como estes para geração de testes:

Compreendendo os componentes de teste gerados

Quando GitHub Copilot gera um teste, ele normalmente cria os seguintes componentes:

• Plano de teste YAML: define a estrutura do teste, a URL do aplicativo e as etapas do teste
• Etapas de teste do Power Fx: contém a lógica de teste usando expressões do Power Fx
• config.json: configuração para parâmetros de execução de teste
• RunTest.ps1: script do PowerShell para executar o teste

Exemplo: estrutura de teste gerada

MyAppTests/
├── MyAppTest.fx.yaml     # Power Fx test steps
├── MyAppTest.yml         # Test plan definition
├── config.json           # Test configuration
└── RunTest.ps1           # Test execution script

Melhores práticas para criação de testes assistidos por IA

Considere as seções a seguir para aproveitar ao máximo o GitHub Copilot para a criação de testes do Test Engine.

Forneça um contexto claro em seus prompts

Seja específico sobre o que você deseja testar e inclua referências a:

• Os arquivos exatos para testar
• Testes de amostra para usar como modelos
• Cenários de teste específicos que você deseja cobrir
• Quaisquer requisitos de autenticação ou ambiente

Usando amostras do Test Engine para contexto

A documentação samples.md cataloga todos os exemplos disponíveis do repositório do Mecanismo de Teste, o que pode ser uma excelente referência ao criar prompts para GitHub Copilot. Por exemplo, ao testar um aplicativo de tela com botões, você pode consultar a amostra do Clicador de Botão:

Prompt:
Gerar um teste para meu aplicativo de tela em ./SolutionPackage/src/CanvasApps/src/MyApp/Src/App.fx.yaml usando a amostra do ButtonClicker de https://github.com/microsoft/PowerApps-TestEngine/tree/main/samples/buttonclicker. O teste deve:
1. Verificar se meu botão de contador incrementa um valor na tela
2. Testar as condições de limite (por exemplo, valor máximo)
3. Incluir os ganchos do ciclo de vida OnTestCaseStart e OnTestCaseComplete
4. Gerar o config.json com as variáveis de ambiente apropriadas

Essa abordagem ajuda Copilot entender a estrutura de teste e gera testes mais precisos e contextualmente relevantes com base em exemplos comprovados.

Use soluções controladas por código-fonte como contexto

Copilot tem o melhor desempenho quando pode analisar sua estrutura de solução. Use o controle do código-fonte para soluções do Power Platform para fornecer este contexto. Esse contexto permite que Copilot:

• Entender a estrutura do seu aplicativo
• Identificar nomes e propriedades de controle
• Gerar etapas de teste mais precisas
• Fazer referência aos caminhos de arquivo corretos

Revisar e refinar os testes gerados

Embora os testes gerados por IA forneçam um excelente ponto de partida, sempre:

• Verifique se as referências de controle correspondem ao seu aplicativo
• Adicione asserções para funcionalidades críticas aos negócios
• Garanta que os casos extremos sejam tratados adequadamente
• Valide a configuração de autenticação

Combine com experiência manual

Para cenários de teste complexos, use GitHub Copilot para:

• Gere a estrutura e o framework de teste
• Crie padrões de validação padrão
• Sugira casos de borda a serem considerados

Em seguida, aumente sua expertise em domínio para:

• Regras de validação específicas do negócio
• Considerações ambientais
• Dados de teste especializados

Padrões comuns de geração de testes

Esta seção contém alguns padrões comuns de geração de testes:

Testando Aplicativos de Tela

Para aplicativos de tela, use prompts que fazem referência ao arquivo App.fx.yaml em sua solução controlada por código-fonte:

Prompt:
Gerar um teste para meu Aplicativo de tela em ./SolutionPackage/src/CanvasApps/src/MyExpenseApp/Src/App.fx.yaml que valide o processo de envio de despesas. O teste deve preencher os campos de despesas, enviar o formulário e verificar se a mensagem de confirmação aparece.

Testando Aplicativos Baseados em Modelos

Para aplicativos baseados em modelo, concentre-se na navegação de entidades, interações de formulários e regras de negócios:

Prompt:
Crie um teste para meu aplicativo baseado em modelo que testa o formulário de entidade Conta. O teste deve criar um novo registro de conta, validar os campos obrigatórios e verificar se as regras de negócios para cálculo de limite de crédito estão funcionando corretamente.

Testando Extensões do Dataverse

Para testes do Dataverse, enfatize as operações de dados e a validação da lógica de negócios:

Prompt:
Gerar um teste do Dataverse que valide os plug-ins personalizados na minha solução. O teste deve criar registros de teste, acionar a execução do plug-in e verificar se ocorreram as transformações de dados esperadas.

Prompts de teste específicos de amostra

Para obter a geração de teste mais precisa, consulte amostras específicas do catálogo de amostras do Test Engine que correspondem às suas necessidades de teste. Aqui estão alguns prompts personalizados para cenários de testes comuns:

Amostra de prompts do ButtonClicker

A amostra do ButtonClicker demonstra testes básicos de funcionalidade do contador. Usar estes prompts:

Prompt:
Gerar um teste para meu aplicativo de contador com uma estrutura semelhante à amostra do ButtonClicker. Meu aplicativo tem botões chamados "IncrementBtn" e "ResetBtn" com um "CounterLabel" que exibe a contagem atual. Crie um teste que verifique se ambos os botões funcionam corretamente e se a contagem máxima é 10.

Prompt:
Crie um teste para meu aplicativo de interação de botões usando a amostra ButtonClicker como referência. Meu aplicativo tem um "SubmitButton" que deve ser habilitado somente quando os campos "NameInput" e "EmailInput" forem preenchidos. Gere um plano de teste com etapas do Power Fx para validar esse comportamento.

Prompts de teste de galeria

As amostras BasicGallery e NestedGallery mostram como testar interações de galeria:

Prompt:
Gere um teste para meu aplicativo de galeria, onde tenho uma galeria "Produtos" com itens de produtos contendo os controles "TitleLabel", "PriceLabel" e "SelectButton". Use a estrutura de amostra BasicGallery para verificar se consigo selecionar itens e se os detalhes corretos aparecem em um "DetailPanel".

Prompts de operações de dados

A amostra do Dataverse demonstra testes de operações de dados:

Prompt:
Criar um teste para meu aplicativo de CRM usando o padrão de amostra do Dataverse. Teste se consigo criar um novo Registro de contato, atualize-o e, então, verificar se as alterações persistem. Inclua testes de IU e operações diretas do Dataverse.

Prompts de teste de IA

Para testar a funcionalidade alimentada por IA, consulte a amostra de Prompt de IA:

Prompt:
Gerar um teste para meu aplicativo de análise de sentimentos com base na amostra do Prompt de IA. Meu aplicativo tem uma caixa de texto "FeedbackInput" e usa AI Builder para classificá-lo como positivo, negativo ou neutro. Crie um teste que valide diferentes entradas e produza saídas esperadas dentro de limites aceitáveis.

Técnicas avançadas

Esta seção fornece exemplos de recursos avançados de prompt.

Criação de suítes de testes de vários ambientes

Você pode solicitar Copilot para gerar testes que funcionam em vários ambientes:

Prompt:
Gerar um conjunto de testes para meu aplicativo que possa ser executado em ambientes DEV, TEST e PROD com variáveis de configuração apropriadas para cada ambiente.

Gerando cenários de simulação de dados

Para testes isolados com simulação de conector:

Prompt:
Crie um teste com respostas de conector simuladas para meu aplicativo que usa o conector Office 365 Outlook. O teste deve simular o recebimento de emails e validar a lógica de processamento do aplicativo.

Testando recursos de IA e lidando com resultados não determinísticos

Ao trabalhar com aplicativos alimentados por IA, os testes apresentam desafios únicos, pois as saídas da IA podem variar ligeiramente entre as execuções, mesmo com entradas idênticas. Esse comportamento não determinístico requer abordagens de testes especiais.

Compreendendo testes não determinísticos

Testes não determinísticos envolvem a validação de saídas que podem variar legitimamente entre execuções de teste:

• AI Model Outputs: respostas de modelos de IA, como GPT ou componentes de AI Builder personalizados
• Pontuações de Confiança: avaliações numéricas que podem oscilar dentro de intervalos aceitáveis
• Conteúdo Gerado: texto ou recomendações produzidos por sistemas de IA

Usando Preview.AIExecutePrompt para testes determinísticos de recursos de IA

O Test Engine fornece o Preview.AIExecutePrompt que permite a validação determinística de respostas de IA. Esta abordagem permite:

• Executar prompts de IA em cenários de teste
• Analisar e validar as respostas estruturadas
• Verificar se os resultados críticos atendem às expectativas, apesar das variações potenciais

Exemplo: avaliação de classificação com AI Builder

O exemplo a seguir demonstra o uso da função Preview.AIExecutePrompt para testar um sistema de classificação alimentado por IA:

EvaluateTestQuestionPrompt(Prompt: TestQuestion): TestResult =
  With({
    Response: ParseJSON(
      Preview.AIExecutePrompt("PromptEvaluator",
      {
        Context: "You are a helpful agent asking about external customer service questions.",
        Question: Prompt.Question
      }).Text)
  },If(
    IsError(AssertNotError(Prompt.ExpectedRating=Response.Rating, Prompt.Question & ", Expected " & Prompt.ExpectedRating & ", Actual " & Response.Rating)),
    {PassFail: 1, Summary: Prompt.Question & ", Expected " & Prompt.ExpectedRating & ", Actual " & Response.Rating}, {PassFail: 0, Summary: "Pass " & Prompt.Question}
  ))

Neste exemplo:

• O teste executa um prompt de IA em relação ao modelo "PromptEvaluator"
• Passa um contexto e uma questão para avaliação
• Valida se a classificação retornada corresponde ao valor esperado
• Fornece feedback claro sobre o sucesso ou fracasso do teste

Você pode explorar a implementação completa na amostra de Prompt de IA do repositório PowerApps-TestEngine.

Incorporando testes com reconhecimento de IA

Ao usar GitHub Copilot para gerar testes para aplicativos alimentados por IA:

Prompt:
Gere um teste para meu aplicativo alimentado por IA que utiliza o processamento de formulários do AI Builder. Inclua etapas de teste que validem os resultados da IA com tolerância apropriada para saídas não determinísticas.

Solução de problemas e refinamento

Se GitHub Copilot gerar testes que não atendem às suas necessidades:

• Refine seu prompt: seja mais específico sobre o que você deseja testar
• Forneça exemplos: link para amostras de teste específicas que correspondem ao seu estilo desejado
• Divida testes complexos: solicite a geração de componentes de teste menores e focados
• Iterate: Use as respostas do Copilot para refinar seu próximo prompt

Artigos relacionados

Explorar os recursos do Test Engine
Navegar pelo catálogo de amostras do Test Engine
Aprender sobre funções de teste Power Fx
Entender o formato do teste YAML
Explorar opções de autenticação
Treinamento: criando aplicativos com o modo de agente do Copilot do GitHub