Compartir por

Creación de probas asistida por IA con GitHub Copilot (vista previa)

Nota

As funcionalidades de vista previa non se deseñaron para uso de produción e poden ter funcionalidade restrinxida. Estas funcionalidades están dispoñibles antes da versión oficial para que os clientes poidan obter acceso a elas rápido e fornecer comentarios.

Crear plans de probas completos para aplicacións pode levar moito tempo, especialmente para escenarios complexos. Power Platform As ferramentas de creación asistidas por IA como GitHub Copilot poden acelerar significativamente este proceso xerando modelos de proba, suxerindo casos de proba e automatizando a creación de código estándar.

Esta guía explica como usar GitHub Copilot con Power Platform solucións de control de código fonte para crear plans de proba de Test Engine de forma eficiente.

Requisitos previos

Antes de comezar, asegúrate de ter:

Configuración do teu entorno de creación de probas

Para maximizar a eficacia da creación de probas asistida por IA, combina estas ferramentas nun fluxo de traballo estruturado:

  1. Obtén os teus ficheiros fonte
  2. Inicializar un repositorio git para o control de versións (se aínda non o fixeches)
  3. Crea un cartafol de probas dedicado no teu repositorio de solucións
  4. Abrir o cartafol da solución en Visual Studio Código

Uso de GitHub Copilot para a creación de probas

GitHub Copilot pode axudarche a xerar varios compoñentes de proba baseados na túa solución controlada polo código fonte. Aquí tes como usar as súas capacidades de forma eficaz:

Usando documentación de exemplo como contexto

O catálogo de mostras de Test Engine ofrece unha rica fonte de material de referencia para GitHub Copilot. Podes axudar a Copilot a xerar probas de maior calidade facendo o seguinte:

  • Incluíndo o ficheiro samples.md no teu espazo de traballo
  • Referenciar exemplos específicos nas túas indicacións
  • Proporcionar ligazóns a repositorios de exemplo de GitHub

Por exemplo, poderías:

  • Abre tanto o código da túa aplicación como o ficheiro samples.md en VS Code
  • Pídelle a Copilot que cree probas "semellantes á mostra de ButtonClicker" ou "usando patróns da mostra" Dataverse
  • Referenciar capacidades específicas de exemplos que se axusten ás súas necesidades de probas

Esta estratexia axuda a Copilot a comprender os patróns do motor de probas e a xerar probas máis precisas. Power Platform

Traballar con GitHub Copilot no modo axente

Visual Studio O chat de Code ofrece un modo de axente que pode axudar a xerar probas baseadas nos ficheiros da solución. GitHub Copilot Este modo permite que Copilot acceda e comprenda o contexto do teu proxecto con maior profundidade.

Para usar o Modo de axente para a xeración de probas:

  1. En VS Code, abre o chat (Ctrl+Maiús+I) GitHub Copilot
  2. Seleccionar Axente no selector de modo Copiloto
  3. Elabora unha proposta detallada sobre a proba que queres crear

Exemplos de solicitudes para a xeración de probas

Tenta usar indicacións como estas para a xeración de probas:

Obxectivo:
Xerar un conxunto de probas completo para unha aplicación de lenzo usando o Power Apps Motor de probas, baseado no exemplo de ButtonClicker.

Solicitude:
Xerar unha proba para ./SolutionPackage/src/CanvasApps/src/MyApp/Src/App.fx.yaml usando o exemplo en https://github.com/microsoft/PowerApps-TestEngine/tree/main/samples/buttonclicker como referencia. Crear casos esperados, casos límite e casos de excepción. A proba debería crear un ficheiro YAML de proba e os pasos de proba, o ficheiro config.json e o ficheiro RunTest.ps1 baseados no exemplo para permitirme executar a proba. Power Fx

Obxectivo:
Crea un plan de probas detallado para unha aplicación baseada en modelos para garantir que a funcionalidade principal e a lóxica empresarial funcionen como se espera.

Solicitude:
Crea un plan de probas completo para a miña aplicación baseada en modelos que se atopa en ./SolutionPackage/src/Other/Solution.xml. A proba debería validar a carga de formularios, a creación de rexistros e a execución de regras empresariais. Xerar o YAML de proba, os Power Fx pasos e un script de PowerShell para executar a proba.

Obxectivo:
Construír un plan de probas para que as entidades verifiquen as operacións CRUD mediante accións. Dataverse Power Fx

Solicitude:
Crea un plan de probas completo para as miñas entidades. Dataverse A proba debería realizar accións de creación, actualización e eliminación. Power Fx Xerar o YAML de proba, os Power Fx pasos e un script de PowerShell para executar a proba.

Comprensión dos compoñentes de proba xerados

Cando GitHub Copilot xera unha proba, normalmente crea os seguintes compoñentes:

  • Plan de probas YAML: Define a estrutura da proba, o URL da aplicación e os pasos da proba
  • Power Fx pasos de proba: Contén a lóxica de proba usando expresións Power Fx
  • config.json: Configuración para os parámetros de execución de probas
  • RunTest.ps1: Script de PowerShell para executar a proba

Exemplo: Estrutura de proba xerada

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

Boas prácticas para a creación de probas asistidas por IA

Ten en conta as seguintes seccións para sacar o máximo proveito da GitHub Copilot creación de probas do motor de probas.

Ofrece un contexto claro nas túas indicacións

Sé específico sobre o que queres probar e inclúe referencias a:

  • Os ficheiros exactos para probar
  • Probas de mostra para usar como modelos
  • Escenarios de proba específicos que queres cubrir
  • Calquera requisito de autenticación ou ambiente

Usando exemplos de Test Engine para contexto

A documentación de samples.md cataloga todos os exemplos dispoñibles do repositorio de Test Engine, que poden ser unha excelente referencia á hora de crear solicitudes para GitHub Copilot. Por exemplo, ao probar unha aplicación de lenzo con botóns, podes consultar o exemplo de *Button Clicker*: ...

Solicitude:
Xerar unha proba para a miña aplicación Canvas en ./SolutionPackage/src/CanvasApps/src/MyApp/Src/App.fx.yaml usando o exemplo de ButtonClicker de https://github.com/microsoft/PowerApps-TestEngine/tree/main/samples/buttonclicker. A proba debería:
1. Verificar que o botón do meu contador incrementa un valor na pantalla
2. Condicións límite de proba (por exemplo, valor máximo)
3. Incluír os ganchos do ciclo de vida OnTestCaseStart e OnTestCaseComplete
4. Xerar o ficheiro config.json coas variables de ambiente axeitadas

Esta estratexia axuda a Copilot a comprender a estrutura da proba e xera probas máis precisas e relevantes para o contexto baseadas en exemplos probados.

Usar solucións controladas por código fonte como contexto

Copilot funciona mellor cando pode analizar a estrutura da túa solución. Usa o control de código fonte para Power Platform solucións para proporcionar este contexto. Este contexto permite a Copilot:

  • Comprender a estrutura da túa aplicación
  • Identificar nomes e propiedades de control
  • Xerar pasos de proba máis precisos
  • Referenciar as rutas de ficheiro correctas

Revisar e refinar as probas xeradas

Aínda que as probas xeradas por IA proporcionan un excelente punto de partida, sempre:

  • Verificar que as referencias de control coincidan coa súa aplicación
  • Engadir asercións para funcionalidades críticas para o negocio
  • Asegurarse de que os casos límite sexan xestionados correctamente
  • Validar a configuración de autenticación

Combina coa experiencia manual

Para escenarios de probas complexos, use GitHub Copilot para:

  • Xerar o marco e a estrutura de probas
  • Crear patróns de validación estándar
  • Suxerir casos límite a considerar

Despois, amplía a túa experiencia no dominio para:

  • Regras de validación específicas do negocio
  • Consideracións ambientais
  • Datos de proba especializados

Patróns comúns de xeración de probas

Esta sección contén algúns patróns comúns de xeración de probas:

Probas de aplicacións de lenzo

Para aplicacións de lenzo, use solicitudes que fagan referencia ao ficheiro App.fx.yaml na súa solución controlada por código fonte:

Solicitude:
Xerar unha proba para a miña aplicación Canvas en ./SolutionPackage/src/CanvasApps/src/MyExpenseApp/Src/App.fx.yaml que valide o proceso de envío de gastos. A proba debería completar os campos de gastos, enviar o formulario e verificar que apareza a mensaxe de confirmación.

Máis información sobre as probas de aplicacións Canvas

Probas de aplicacións baseadas en modelos

Para aplicacións baseadas en modelos, céntrate na navegación de entidades, as interaccións de formularios e as regras de negocio:

Solicitude:
Crea unha proba para a miña aplicación baseada en modelos que avalíe o formulario da entidade Conta. A proba debería crear un novo rexistro de conta, validar os campos obrigatorios e verificar que as regras empresariais para o cálculo do límite de crédito funcionan correctamente.

Máis información sobre as probas de aplicacións baseadas en modelos

Probando Dataverse Extensións

Para as probas, fíxate nas operacións con datos e na validación da lóxica empresarial: Dataverse

Solicitude:
Xerar unha Dataverse proba que valide os complementos personalizados na miña solución. A proba debería crear rexistros de proba, activar a execución do complemento e verificar que se produciron as transformacións de datos esperadas.

Máis información sobre as probas Dataverse

Solicitudes de proba específicas para mostras

Para obter a xeración de probas máis precisa, consulta exemplos específicos do catálogo de exemplos do motor de probas que se axusten ás túas necesidades de probas. Aquí tes indicacións personalizadas para escenarios de probas comúns:

Exemplos de solicitudes de ButtonClicker

O exemplo de ButtonClicker demostra as probas básicas da funcionalidade do contador. Usa estas indicacións:

Solicitude:
Xerar unha proba para a miña aplicación de contador cunha estrutura similar ao exemplo de ButtonClicker. A miña aplicación ten botóns chamados "IncrementBtn" e "ResetBtn" cunha "CounterLabel" que mostra a conta actual. Crea unha proba que verifique que ambos botóns funcionan correctamente e que o número máximo é 10.

Solicitude:
Crea unha proba para a miña aplicación de interacción con botóns usando o exemplo de ButtonClicker como referencia. A miña aplicación ten un "SubmitButton" que só debería estar activado cando se completan os campos "NameInput" e "EmailInput". Xerar un plan de probas con Power Fx pasos para validar este comportamento.

Os exemplos BasicGallery e NestedGallery amosan como probar as interaccións da galería:

Solicitude:
Xerar unha proba para a miña aplicación de galería onde teño unha galería de "Produtos" con elementos de produto que conteñen os controis "TitleLabel", "PriceLabel" e "SelectButton". Usa a estrutura de exemplo de BasicGallery para verificar que podo seleccionar elementos e que os detalles correctos aparecen nun "DetailPanel".

Solicitudes de operacións con datos

A Dataverse mostra a proba das operacións con datos:

Solicitude:
Crea unha proba para a miña aplicación CRM usando o patrón de exemplo Dataverse . Probar que podo crear un novo rexistro de contacto, actualizalo e, a seguir, verificar que os cambios persisten. Inclúe tanto as probas da interface de usuario como as operacións directas. Dataverse

Solicitudes de probas de IA

Para probar a funcionalidade con tecnoloxía de IA, consulta o exemplo de solicitude de IA:

Solicitude:
Xerar unha proba para a miña aplicación de análise de sentimentos baseada no exemplo de IA Prompt. A miña aplicación ten unha caixa de texto "Entrada de comentarios" e úsaa AI Builder para clasificala como positiva, negativa ou neutra. Crea unha proba que valide que as diferentes entradas producen saídas esperadas dentro dos limiares aceptables.

Técnicas avanzadas

Esta sección ofrece exemplos de funcionalidades avanzadas de solicitudes.

Creación de conxuntos de probas multiambiente

Podes solicitar a Copilot que xere probas que funcionen en varios entornos:

Solicitude:
Xerar un conxunto de probas para a miña aplicación que poida executarse en entornos DEV, TEST e PROD con variables de configuración axeitadas para cada entorno.

Xeración de escenarios de simulación de datos

Para probas illadas con simulación de conectores:

Solicitude:
Crea unha proba con respostas de conectores simulados para a miña aplicación que use o conector Outlook Office 365 . A proba debería simular a recepción de correos electrónicos e validar a lóxica de procesamento da aplicación.

Probas de capacidades de IA e xestión de resultados non deterministas

Cando se traballa con aplicacións baseadas en IA, as probas presentan desafíos únicos, xa que os resultados da IA poden variar lixeiramente entre execucións, mesmo con entradas idénticas. Este comportamento non determinista require enfoques de proba especiais.

Comprender as probas non deterministas

As probas non deterministas implican validar saídas que poderían variar lexitimamente entre as execucións das probas:

  • Saídas do modelo de IA: Respostas de modelos de IA como GPT ou compoñentes AI Builder personalizados
  • Puntuacións de confianza: Avaliacións numéricas que poden fluctuar dentro de rangos aceptables
  • Contido xerado: Texto ou recomendacións producidas por sistemas de IA

Uso de Preview.AIExecutePrompt para probas deterministas das capacidades da IA

O motor de probas proporciona a opción *Preview.AIExecutePrompt* que permite a validación determinista das respostas da IA. ... Esta estratexia permíteche:

  • Executar solicitudes de IA dentro de escenarios de proba
  • Analizar e validar as respostas estruturadas
  • Verificar que os resultados críticos cumpran as expectativas a pesar das posibles variacións

Exemplo: Avaliación da cualificación con AI Builder

O seguinte exemplo demostra o uso da función Preview.AIExecutePrompt para probar un sistema de clasificación baseado en 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:

  • A proba executa unha solicitude de IA contra o modelo "PromptEvaluator"
  • Pasa un contexto e unha pregunta para a avaliación
  • Valida que a cualificación devolvida coincide co valor esperado
  • Ofrece información clara sobre o éxito ou o fracaso da proba

Podes explorar a implementación completa no exemplo de AI Prompt do repositorio PowerApps-TestEngine .

Incorporando probas compatibles coa IA

Ao usar GitHub Copilot para xerar probas para aplicacións con tecnoloxía de IA:

Solicitude:
Xerar unha proba para a miña aplicación con tecnoloxía de IA que emprega o procesamento de formularios. AI Builder Incluír pasos de proba que validen os resultados da IA coa tolerancia axeitada para saídas non deterministas.

Resolución de problemas e refinamento

Se GitHub Copilot xera probas que non satisfacen as túas necesidades:

  • Refina a túa solicitude: Sé máis específico sobre o que queres probar
  • Proporcionar exemplos: Ligazón a mostras de proba específicas que coincidan co estilo desexado
  • Desglosar probas complexas: Solicitar a xeración de compoñentes de proba máis pequenos e específicos
  • Iterar: Usa as respostas de Copilot para refinar a túa seguinte solicitude

Explorar as funcionalidades do motor de probas
Explorar o catálogo de mostras do motor de probas
Máis información sobre as funcións de proba Power Fx
Comprender o formato de proba YAML
Explorar as opcións de autenticación
Formación: Creación de aplicacións co modo axente GitHub Copilot

  • Last updated on