Criação de testes assistida por IA com GitHub Copilot (prévia)

Criar planos de teste abrangentes para Power Platform aplicativos pode ser demorado, 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 padrão.

Este guia explica como usar GitHub Copilot com Power Platform soluções de controle de origem para criar planos de teste do Test Engine de forma eficiente.

Pré-requisitos

Antes de começar, certifique-se de ter:

• Visual Studio Código instalado
• GitHub Copilot subscrição
• GitHub Copilot Extensão de bate-papo para VS Code
• Power Platform CLI instalado
• Uma solução controlada pela fonte Power Platform

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 Power Platform ambiente ou 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 de soluções em Visual Studio Código

Usando GitHub Copilot para criação de testes

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

Usando documentação de amostra como contexto

O catálogo de amostras do Test Engine fornece uma rica fonte de material de referência para GitHub Copilot. Você pode ajudar o 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 amostra do GitHub

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 "semelhantes ao exemplo do ButtonClicker" ou "usando padrões do Dataverse exemplo"
• Faça referência a recursos específicos de amostras que correspondem às suas necessidades de teste

Essa abordagem ajuda o Copilot a entender os padrões do mecanismo de teste e gerar testes mais precisos. Power Platform

Trabalhando com GitHub Copilot no Modo Agente

Visual Studio O Chat do Code oferece um Modo de Agente que pode ajudar a gerar testes com base nos seus arquivos de solução. GitHub Copilot Este modo permite que o Copilot acesse e entenda o contexto do seu projeto mais profundamente.

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

1. No VS Code, abra o Chat (Ctrl+Shift+I) GitHub Copilot
2. Selecione Agente no seletor de modo Copiloto
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
• Power Fx etapas de teste: Contém a lógica de teste usando Power Fx expressões
• 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 a criação de testes do Test Engine. GitHub Copilot

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 catálogos de todos os exemplos disponíveis no repositório do Test Engine, que podem 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 o exemplo do Clicker de botão:

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

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

Use soluções controladas por fonte como contexto

O Copilot tem melhor desempenho quando consegue analisar a estrutura da sua solução. Use controle de origem para Power Platform soluções para fornecer este contexto. Este contexto permite ao Copilot:

• Entenda a estrutura do seu aplicativo
• Identificar nomes e propriedades de controle
• Gere etapas de teste mais precisas
• Faça 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 à sua aplicação
• Adicionar asserções para funcionalidades críticas aos negócios
• Garantir que os casos extremos sejam tratados adequadamente
• Validar configuração de autenticação

Combine com experiência manual

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

• Gerar a estrutura e o framework de teste
• Crie padrões de validação padrão
• Sugira casos extremos 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 Canvas

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

Incitar:
Gerar um teste para meu aplicativo Canvas 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 orientados a modelos

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

Incitar:
Crie um teste para meu aplicativo orientado a 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 comerciais para cálculo de limite de crédito estão funcionando corretamente.

Testando extensões Dataverse

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

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

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:

Exemplos de prompts do ButtonClicker

O exemplo ButtonClicker demonstra testes básicos de funcionalidade do contador. Use estas instruções:

Incitar:
Gere um teste para meu aplicativo de contador com uma estrutura semelhante ao exemplo 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.

Incitar:
Crie um teste para meu aplicativo de interação de botões usando o exemplo 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 Power Fx etapas para validar esse comportamento.

Prompts de teste de galeria

Os exemplos BasicGallery e NestedGallery mostram como testar interações de galeria:

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

Prompts de operações de dados

O Dataverse exemplo demonstra testes de operações de dados:

Incitar:
Crie um teste para meu aplicativo de CRM usando o Dataverse padrão de exemplo. Testar se consigo criar um novo registro de contato, atualizá-lo e, então, verificar se as alterações persistem. Inclui testes de IU e operações diretas. Dataverse

Prompts de teste de IA

Para testar a funcionalidade com tecnologia de IA, consulte o exemplo de prompt de IA:

Incitar:
Gerar um teste para meu aplicativo de análise de sentimentos com base no exemplo do AI Prompt. 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 multiambiente

Você pode solicitar que o Copilot gere testes que funcionem em vários ambientes:

Incitar:
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:

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

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

Ao trabalhar com aplicativos baseados em 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:

• Saídas do modelo de IA: Respostas de modelos de IA como GPT ou componentes 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 capacidades de IA

O mecanismo de teste fornece o Preview.AIExecutePrompt que permite a validação determinística de respostas de IA. Essa abordagem permite que você:

• Execute prompts de IA em cenários de teste
• Analisar e validar as respostas estruturadas
• Verifique 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 no exemplo do AI Prompt do repositório PowerApps-TestEngine .

Incorporando testes com reconhecimento de IA

Ao usar GitHub Copilot para gerar testes para aplicativos com tecnologia de IA:

Incitar:
Gerar um teste para meu aplicativo com tecnologia de IA que usa AI Builder processamento de formulários. 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
• Decomponha testes complexos: Solicite a geração de componentes de teste menores e focados
• Iterar: Use as respostas do Copilot para refinar seu próximo prompt

Artigos relacionados

Explore os recursos do Test Engine
Navegue pelo catálogo de amostras do Test Engine
Aprenda sobre funções de teste Power Fx
Entenda o formato do teste YAML
Explorar opções de autenticação
Treinamento: Construindo aplicações com modo agente GitHub Copilot