Condividi tramite

Creazione di test assistita dall'intelligenza artificiale con GitHub Copilot (anteprima)

Nota

Le funzionalità di anteprima non sono destinate ad essere utilizzate per la produzione e sono soggette a restrizioni. Vengono rese disponibili prima di una versione ufficiale in modo che i clienti possano accedervi con anticipo e fornire i loro commenti.

Creare piani di test completi per le applicazioni può richiedere molto tempo, soprattutto nel caso di scenari complessi. Power Platform Strumenti di creazione assistiti dall'intelligenza artificiale come GitHub Copilot possono accelerare notevolmente questo processo generando modelli di test, suggerendo casi di test e automatizzando la creazione di codice boilerplate.

Questa guida spiega come utilizzare GitHub Copilot con Power Platform soluzioni di controllo del codice sorgente per creare in modo efficiente piani di test di Test Engine.

Prerequisiti

Prima di iniziare, assicurati di avere:

Impostazione dell'ambiente di creazione dei test

Per massimizzare l'efficacia della creazione di test assistiti dall'intelligenza artificiale, combina questi strumenti in un flusso di lavoro strutturato:

  1. Ottieni i tuoi file sorgente
  2. Inizializzare un repository git per il controllo della versione (se non è già stato fatto)
  3. Crea una cartella di test dedicata nel tuo repository di soluzioni
  4. Aprire la cartella della soluzione in Visual Studio Codice

Utilizzo GitHub Copilot per la creazione di test

GitHub Copilot può aiutarti a generare vari componenti di test in base alla tua soluzione con controllo sorgente. Ecco come sfruttarne al meglio le potenzialità:

Utilizzo della documentazione di esempio come contesto

Il catalogo dei campioni del Test Engine fornisce una ricca fonte di materiale di riferimento per . GitHub Copilot Puoi aiutare Copilot a generare test di qualità superiore:

  • Includere il file samples.md nel tuo spazio di lavoro
  • Fare riferimento a campioni specifici nei tuoi prompt
  • Fornire link a repository GitHub di esempio

È ad esempio possibile:

  • Apri sia il codice dell'applicazione che il file samples.md in VS Code
  • Chiedi a Copilot di creare test "simili all'esempio ButtonClicker" o "utilizzando modelli dall'esempio" Dataverse
  • Fai riferimento alle capacità specifiche dei campioni che corrispondono alle tue esigenze di test

Questo approccio aiuta Copilot a comprendere i modelli del Test Engine e a generare test più accurati. Power Platform

Lavorare con GitHub Copilot in modalità agente

Visual Studio La chat di Code offre una GitHub Copilot modalità agente che può aiutare a generare test basati sui file della soluzione. Questa modalità consente a Copilot di accedere e comprendere più approfonditamente il contesto del progetto.

Per utilizzare la modalità agente per la generazione dei test:

  1. In VS Code, apri GitHub Copilot Chat (Ctrl+Maiusc+I)
  2. Seleziona Agente dal selettore della modalità Copilota
  3. Crea un prompt dettagliato sul test che vuoi creare

Esempi di prompt per la generazione di test

Prova a utilizzare prompt come questi per la generazione dei test:

Obiettivo:
Genera una suite di test completa per un'app canvas utilizzando il Power Apps Test Engine, modellato sull'esempio ButtonClicker.

Richiesta:
Genera un test per ./SolutionPackage/src/CanvasApps/src/MyApp/Src/App.fx.yaml utilizzando l'esempio in https://github.com/microsoft/PowerApps-TestEngine/tree/main/samples/buttonclicker come riferimento. Crea casi previsti, casi limite e casi eccezionali. Il test dovrebbe creare un file YAML di test e Power Fx passaggi di test, config.json e RunTest.ps1 basati sull'esempio per consentirmi di eseguire il test.

Obiettivo:
Crea un piano di test dettagliato per un'app basata su modello per garantire che le funzionalità principali e la logica aziendale funzionino come previsto.

Richiesta:
Crea un piano di test completo per la mia app basata su modello che si trova in ./SolutionPackage/src/Other/Solution.xml. Il test dovrebbe convalidare il caricamento del modulo, la creazione del record e l'esecuzione delle regole aziendali. Generare il test YAML, i passaggi e uno script di PowerShell per eseguire il test. Power Fx

Obiettivo:
Costruire un piano di test per le entità per verificare le operazioni CRUD tramite azioni. Dataverse Power Fx

Richiesta:
Creare un piano di test completo per le mie Dataverse entità. Il test dovrebbe eseguire azioni di creazione, aggiornamento, eliminazione. Power Fx Generare il test YAML, i passaggi e uno script di PowerShell per eseguire il test. Power Fx

Comprensione dei componenti di test generati

Quando GitHub Copilot genera un test, in genere crea i seguenti componenti:

  • Piano di test YAML: definisce la struttura del test, l'URL dell'app e i passaggi del test
  • Power Fx passaggi di test: contiene la logica di test utilizzando le espressioni Power Fx
  • config.json: Configurazione per i parametri di esecuzione del test
  • RunTest.ps1: script di PowerShell per eseguire il test

Esempio: struttura di test generata

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

Le migliori pratiche per la creazione di test assistiti dall'intelligenza artificiale

Per sfruttare al meglio la creazione di test con GitHub Copilot Test Engine, prendi in considerazione le seguenti sezioni.

Fornisci un contesto chiaro nei tuoi prompt

Sii specifico su cosa vuoi testare e includi riferimenti a:

  • I file esatti da testare
  • Test di esempio da utilizzare come modelli
  • Scenari di test specifici che desideri coprire
  • Eventuali requisiti di autenticazione o ambiente

Utilizzo di campioni di Test Engine per il contesto

La documentazione samples.md cataloga tutti i campioni disponibili nel repository Test Engine, che possono rappresentare un ottimo riferimento durante la creazione di prompt per GitHub Copilot. Ad esempio, quando si testa un'app canvas con pulsanti, è possibile fare riferimento all' esempio Button Clicker:

Richiesta:
Genera un test per la mia app Canvas in ./SolutionPackage/src/CanvasApps/src/MyApp/Src/App.fx.yaml utilizzando l'esempio ButtonClicker da https://github.com/microsoft/PowerApps-TestEngine/tree/main/samples/buttonclicker. Il test dovrebbe:
1. Verificare che il pulsante del contatore incrementi un valore sullo schermo
2. Verificare le condizioni al contorno (ad esempio, valore massimo)
3. Includere gli hook del ciclo di vita OnTestCaseStart e OnTestCaseComplete
4. Generare il file config.json con le variabili d'ambiente appropriate

Questo approccio aiuta Copilot a comprendere la struttura del test e a generare test più accurati e contestualmente rilevanti, basati su esempi comprovati.

Utilizzare soluzioni controllate alla fonte come contesto

Copilot funziona al meglio quando riesce ad analizzare la struttura della soluzione. Utilizzare controllo sorgente per Power Platform soluzioni per fornire questo contesto. Questo contesto consente a Copilot di:

  • Comprendi la struttura della tua app
  • Identificare i nomi e le proprietà dei controlli
  • Generare passaggi di test più accurati
  • Fare riferimento ai percorsi dei file corretti

Rivedere e perfezionare i test generati

Sebbene i test generati dall'intelligenza artificiale costituiscano un ottimo punto di partenza, è sempre opportuno:

  • Verifica che i riferimenti di controllo corrispondano alla tua applicazione
  • Aggiungere asserzioni per funzionalità critiche per l'azienda
  • Garantire che i casi limite siano gestiti correttamente
  • Convalida la configurazione di autenticazione

Combina con competenza manuale

Per scenari di test complessi, utilizzare GitHub Copilot per:

  • Generare il framework e la struttura del test
  • Creare modelli di convalida standard
  • Suggerisci casi limite da considerare

Quindi arricchisci con la tua competenza nel settore per:

  • Regole di convalida specifiche per l'azienda
  • Considerazioni ambientali
  • Dati di test specializzati

Modelli comuni di generazione di test

Questa sezione contiene alcuni modelli comuni di generazione di test:

Test delle app Canvas

Per le app canvas, utilizza i prompt che fanno riferimento al file App.fx.yaml nella tua soluzione con controllo sorgente:

Richiesta:
Genera un test per la mia app Canvas in ./SolutionPackage/src/CanvasApps/src/MyExpenseApp/Src/App.fx.yaml che convalidi il processo di invio delle spese. Il test dovrebbe popolare i campi delle spese, inviare il modulo e verificare che venga visualizzato il messaggio di conferma.

Scopri di più sui test delle app Canvas

Test di app basate su modelli

Per le app basate su modelli, concentrati sulla navigazione delle entità, sulle interazioni dei moduli e sulle regole aziendali:

Richiesta:
Crea un test per la mia app basata su modello che verifichi il modulo dell'entità Account. Il test dovrebbe creare un nuovo record di account, convalidare i campi obbligatori e verificare che le regole aziendali per il calcolo del limite di credito funzionino correttamente.

Scopri di più sui test delle app basati su modelli

Estensioni di test Dataverse

Per i test, enfatizzare le operazioni sui dati e la convalida della logica aziendale: Dataverse

Richiesta:
Genera un test che convalidi i plugin personalizzati nella mia soluzione. Dataverse Il test dovrebbe creare record di prova, attivare l'esecuzione del plugin e verificare che siano avvenute le trasformazioni dei dati previste.

Scopri di più sui test Dataverse

Richieste di test specifiche per campione

Per ottenere la generazione di test più accurata, fai riferimento a campioni specifici dal catalogo dei campioni del Test Engine che corrispondono alle tue esigenze di test. Ecco alcuni prompt personalizzati per scenari di test comuni:

Esempi di prompt di ButtonClicker

L'esempio di ButtonClicker illustra i test di funzionalità di base del contatore. ... Utilizza questi suggerimenti:

Richiesta:
Genera un test per la mia app contatore con una struttura simile all'esempio ButtonClicker. La mia app ha pulsanti denominati "IncrementBtn" e "ResetBtn" con una "CounterLabel" che mostra il conteggio corrente. Crea un test che verifichi che entrambi i pulsanti funzionino correttamente e che il conteggio massimo sia 10.

Richiesta:
Crea un test per la mia app di interazione con i pulsanti utilizzando l'esempio ButtonClicker come riferimento. La mia app ha un "SubmitButton" che dovrebbe essere abilitato solo quando i campi "NameInput" e "EmailInput" sono compilati. Generare un piano di test con Power Fx passaggi per convalidare questo comportamento.

Gli esempi BasicGallery e NestedGallery mostrano come testare le interazioni della galleria:

Richiesta:
Genera un test per la mia app galleria in cui ho una galleria "Prodotti" con articoli di prodotto contenenti i controlli "TitleLabel", "PriceLabel" e "SelectButton". Utilizzare la struttura di esempio BasicGallery per verificare se riesco a selezionare gli elementi e se i dettagli corretti vengono visualizzati in un "DetailPanel".

Richieste di operazioni sui dati

L' Dataverse esempio dimostra il test delle operazioni sui dati:

Richiesta:
Crea un test per la mia app CRM utilizzando il modello di esempio. Dataverse Prova a creare un nuovo record di contatto, aggiornarlo e verificare che le modifiche vengano mantenute. Includere sia test dell'interfaccia utente sia operazioni dirette. Dataverse

Richieste di test di intelligenza artificiale

Per testare le funzionalità basate sull'intelligenza artificiale, fare riferimento all' esempio di prompt AI:

Richiesta:
Genera un test per la mia app di analisi del sentiment basato sull'esempio di AI Prompt. La mia app ha una casella di testo "FeedbackInput" e la usa per classificarla come positiva, negativa o neutra. AI Builder Creare un test che convalidi diversi input e produca gli output previsti entro soglie accettabili.

Tecniche avanzate

Questa sezione fornisce esempi di funzionalità avanzate di prompt.

Creazione di suite di test multi-ambiente

Puoi chiedere a Copilot di generare test che funzionano in più ambienti:

Richiesta:
Generare una suite di test per la mia app che possa essere eseguita in ambienti DEV, TEST e PROD con variabili di configurazione appropriate per ciascun ambiente.

Generazione di scenari di simulazione dei dati

Per test isolati con simulazione del connettore:

Richiesta:
Crea un test con risposte di connettori simulate per la mia app che utilizza il connettore Outlook. Office 365 Il test dovrebbe simulare la ricezione di e-mail e convalidare la logica di elaborazione dell'app.

Testare le capacità dell'intelligenza artificiale e gestire risultati non deterministici

Quando si lavora con applicazioni basate sull'intelligenza artificiale, i test introducono sfide particolari, poiché gli output dell'intelligenza artificiale potrebbero variare leggermente da un'esecuzione all'altra, anche con input identici. Questo comportamento non deterministico richiede approcci di test speciali.

Comprensione dei test non deterministici

I test non deterministici comportano la convalida di output che potrebbero legittimamente variare durante le esecuzioni dei test:

  • Output del modello AI: risposte da modelli AI come GPT o componenti personalizzati AI Builder
  • Punteggi di confidenza: valutazioni numeriche che potrebbero oscillare entro intervalli accettabili
  • Contenuto generato: testo o raccomandazioni prodotti da sistemi di intelligenza artificiale

Utilizzo di Preview.AIExecutePrompt per test deterministici delle capacità dell'IA

Il Test Engine fornisce Preview.AIExecutePrompt che consente la convalida deterministica delle risposte dell'IA. Questo approccio consente di:

  • Eseguire richieste di intelligenza artificiale all'interno di scenari di test
  • Analizzare e convalidare le risposte strutturate
  • Verificare che gli output critici soddisfino le aspettative nonostante le potenziali variazioni

Esempio: Valutazione della valutazione con AI Builder

L'esempio seguente illustra l'utilizzo della funzione Preview.AIExecutePrompt per testare un sistema di valutazione basato sull'intelligenza artificiale:

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}
  ))

In questo esempio:

  • Il test esegue un prompt AI sul modello "PromptEvaluator"
  • Passa un contesto e una domanda di valutazione
  • Convalida che la valutazione restituita corrisponda al valore atteso
  • Fornisce un feedback chiaro sul successo o sul fallimento del test

È possibile esplorare l'implementazione completa nell' esempio di prompt AI dal repository PowerApps-TestEngine .

Incorporare test basati sull'intelligenza artificiale

Quando si utilizza GitHub Copilot per generare test per applicazioni basate sull'intelligenza artificiale:

Richiesta:
Genera un test per la mia app basata sull'intelligenza artificiale che utilizza l'elaborazione dei moduli. AI Builder Includere fasi di test che convalidano i risultati dell'IA con tolleranza adeguata per gli output non deterministici.

Risoluzione dei problemi e perfezionamento

Se GitHub Copilot genera test che non soddisfano le tue esigenze:

  • Perfeziona il tuo prompt: sii più specifico su ciò che vuoi testare
  • Fornisci esempi: collega a campioni di test specifici che corrispondono allo stile desiderato
  • Suddividere i test complessi: richiedere la generazione di componenti di test più piccoli e mirati
  • Ripetizione: utilizza le risposte del Copilota per perfezionare il tuo prossimo prompt

Esplora le funzionalità del Test Engine
Sfoglia il catalogo dei campioni di Test Engine
Scopri di più sulle Power Fx funzioni di test
Comprendere il formato del test YAML
Esplora le opzioni di autenticazione
Formazione: creazione di applicazioni con modalità agente GitHub Copilot

  • Last updated on