ALM in Power Platform con Test Engine (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.

L'Application Lifecycle Management (ALM) è un approccio completo alla gestione del ciclo di vita delle applicazioni, dall'ideazione iniziale allo sviluppo, ai test, all'implementazione e alla manutenzione continua. Nel contesto di Power Platform, l'integrazione di test automatizzati con Test Engine nel processo ALM garantisce che le applicazioni vengano testate accuratamente in ogni fase di sviluppo, con conseguenti rilasci di qualità superiore.

Comprendere l'automazione dei test in ALM

L'automazione dei test svolge un ruolo fondamentale nel processo ALM perché:

• Garantire la qualità - Verificare che le applicazioni funzionino come previsto prima della distribuzione
• Riduzione del rischio - Individuare i problemi in anticipo, prima che raggiungano gli ambienti di produzione
• Abilitazione dell'integrazione continua - Supporto dei test di verifica automatizzati della build
• Facilitazione delle distribuzioni controllate - Aggiunta di controlli di qualità alle pipeline di rilascio

Con Power Apps Test Engine puoi integrare i test automatizzati nei tuoi flussi di lavoro ALM esistenti, indipendentemente dagli strumenti CI/CD che utilizzi. Power Platform

Ciclo di vita dell'automazione dei test

Il Test Engine supporta un ciclo di vita di test completo che si integra con i processi ALM:

1. Sviluppo - Crea ed esegui test localmente durante lo sviluppo dell'app
2. Convalida della build - Esegui test come parte della verifica automatizzata della build
3. Gate di rilascio - Utilizzare i risultati dei test come gate di qualità per distribuzioni controllate
4. Verifica della produzione - Convalida delle funzionalità critiche negli ambienti di produzione

Introduzione all'automazione dei test in ALM

Per iniziare a integrare Test Engine nei tuoi processi ALM:

1. Crea il tuo piano di test - Progetta piani di test YAML per le tue Power Platform soluzioni
2. Esegui i test localmente - Verifica che i test funzionino nel tuo ambiente di sviluppo
3. Imposta l'autenticazione - Configura l'autenticazione appropriata per i tuoi ambienti di esecuzione e pipeline locali
4. Integrazione con la tua pipeline - Collega Test Engine alla tua pipeline ALM esistente
5. Implementare controlli di qualità - Utilizzare i risultati dei test per controllare la promozione delle soluzioni

Suggerimento

Inizia con i percorsi utente critici ed espandi gradualmente la copertura dei test automatizzati man mano che acquisisci familiarità con Test Engine.

Versione del codice sorgente del Test Engine (facoltativa)

Se stai utilizzando la versione del codice sorgente di Test Engine, avrai anche bisogno di:

• .NET 8.0 SDK - Se si prevede di creare Test Engine dal codice sorgente
• Git - Per estrarre le modifiche dal repository Power Apps Test Engine
• Completa i passaggi di installazione del codice sorgente per eseguire i test utilizzando la versione compilata locale di Test Engine

Opzioni di integrazione

Il motore di test si integra perfettamente con vari strumenti e processi ALM

Esecuzione locale

È possibile utilizzare un editor locale come Visual Studio Codice per modificare i file YAML per creare i test del Test Engine. Per eseguire i test in locale:

1. Assicurati di aver installato Microsoft Power Platform CLI
2. Se stai utilizzando l' integrazione del controllo sorgente clona il tuo progetto sul tuo computer locale
3. Utilizza il test di esecuzione del pac per eseguire il test
4. Rivedi i risultati di superamento/fallimento del test

L' interfaccia della riga di comando di Azure è essenziale per ottenere i token di accesso a cui connettersi Dataverse. A livello locale, puoi utilizzare:

az login --allow-no-subscriptions

Power Platform Condotte

Puoi integrare facilmente Test Engine con le pipeline integrate di Power Platform per un'esperienza integrata nativa:

• Pipeline di soluzioni - Aggiungi test automatizzati alle tue pipeline di soluzioni per garantire la qualità in ogni fase
• Strategia ambientale - Eseguire test in ambienti di sviluppo e test prima di promuovere in produzione
• Modelli di pipeline - Utilizza i modelli di pipeline per standardizzare i test in tutta l'organizzazione

È possibile attivare l'esecuzione di test automatizzati quando si utilizza un host di pipeline personalizzate:

1. Crea un flusso cloud che si attiva in base agli eventi della pipeline Power Automate
2. Connettiti al tuo sistema CI/CD per eseguire i test
3. Elaborare i risultati dei test e aggiornare lo stato della pipeline

Il diagramma seguente mostra un esempio di questo modello di integrazione:

Questo flusso utilizza:

• Dataverse Trigger per avviare una pipeline quando vengono soddisfatte le condizioni
• Condizioni di attivazione per determinare quale fase di distribuzione si applica
• Azure DevOps Connettore per avviare una build con parametri
• Azioni di approvazione per gestire il processo di approvazione
• Dataverse Azioni per aggiornare la pipeline in base ai risultati

Integrazione CI/CD personalizzata con Power Automate

Per le organizzazioni dotate di strumenti CI/CD esistenti, Test Engine si integra con pipeline personalizzate tramite la funzionalità Power Automate Custom Host Power Platform Custom Host . Con l'approccio Host personalizzato, puoi:

• Definisci un host di pipeline personalizzato che esegua i tuoi test automatizzati
• Crea flussi cloud che si attivano automaticamente dagli eventi di distribuzione Power Automate
• Esegui comandi direttamente dai flussi cloud per eseguire test archiviati nel controllo sorgente pac test run
• Connettiti al tuo sistema CI/CD preferito (Azure DevOps, GitHub Actions, ecc.)
• Implementare flussi di lavoro di approvazione basati sui risultati dei test
• Aggiorna lo stato di distribuzione in base ai risultati dei test

Questa integrazione ti consente di mantenere i tuoi investimenti CI/CD esistenti aggiungendo le funzionalità di Test Engine al tuo processo ALM. L'host personalizzato funge da ponte tra le funzionalità ALM native di Power Platform e la tua infrastruttura di test esterna.

Pipeline DevOps

Puoi estendere la tua Power Platform Pipeline utilizzando un host personalizzato o integrare direttamente il comando pac test run per eseguire i tuoi script di build.

Ecco un esempio di un file YAML di pipeline che mostra come impostare ed eseguire i test di Test Engine: Azure DevOps Power Apps

trigger:
- main

pool:
  vmImage: 'windows-latest'

variables:
  - group: PowerPlatformTestVariables # Create a variable group with these variables
  # Required variables in the variable group:
  # ClientId - Service Principal App ID
  # ClientSecret - Service Principal Secret (mark as secret)
  # TenantId - Microsoft Entra Tenant ID
  # EnvironmentUrl - Power Platform Environment URL
  # EnvironmentId - Power Platform Environment ID

steps:
# Download the test plan file from secure files
- task: DownloadSecureFile@1
  name: testPlan
  displayName: 'Download Test Plan File'
  inputs:
    secureFile: 'testplan.te.yaml' # Upload your test plan to Secure Files in Azure DevOps

# Install Power Platform CLI
- task: PowerShell@2
  displayName: 'Install Power Platform CLI'
  inputs:
    targetType: 'inline'
    script: |
      Write-Host "Installing Power Platform CLI..."
      $pacUrl = "https://aka.ms/PowerAppsCLI"
      $pacZip = "$env:TEMP\pac.zip"
      $pacDestination = "$env:TEMP\pac"
      
      # Create the destination folder if it doesn't exist
      if (-not (Test-Path $pacDestination)) {
          New-Item -ItemType Directory -Path $pacDestination -Force | Out-Null
      }
      
      # Download PAC CLI
      Invoke-WebRequest -Uri $pacUrl -OutFile $pacZip
      
      # Extract PAC CLI
      Expand-Archive -Path $pacZip -DestinationPath $pacDestination -Force
      
      # Add PAC CLI to PATH
      $env:PATH = "$pacDestination;$env:PATH"
      
      # Verify installation
      pac help

# Install Azure CLI and authenticate with service principal
- task: PowerShell@2
  displayName: 'Install Azure CLI and Authenticate'
  inputs:
    targetType: 'inline'
    script: |
      Write-Host "Installing Azure CLI..."
      $azureCliUrl = "https://aka.ms/installazurecliwindows"
      $azureCliInstaller = "$env:TEMP\AzureCLI.msi"
      
      # Download Azure CLI installer
      Invoke-WebRequest -Uri $azureCliUrl -OutFile $azureCliInstaller
      
      # Install Azure CLI silently
      Start-Process -FilePath msiexec.exe -Args "/i $azureCliInstaller /quiet /norestart" -Wait
      
      # Reload PATH to include Azure CLI
      $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH", "User")
      
      # Authenticate with service principal
      Write-Host "Authenticating with Azure CLI..."
      az login --service-principal -u "$(ClientId)" -p "$(ClientSecret)" --tenant "$(TenantId)" --allow-no-subscriptions

# Authenticate PAC CLI with service principal
- task: PowerShell@2
  displayName: 'Authenticate PAC CLI'
  inputs:
    targetType: 'inline'
    script: |
      Write-Host "Authenticating PAC CLI..."
      
      # Create authentication profile
      pac auth create --name TestEngineAuth --url "$(EnvironmentUrl)" --applicationId "$(ClientId)" --clientSecret "$(ClientSecret)" --tenant "$(TenantId)"
      
      # Select the authentication profile
      pac auth select --name TestEngineAuth

# Run the tests
- task: PowerShell@2
  displayName: 'Execute Test Engine Tests'
  inputs:
    targetType: 'inline'
    script: |
      Write-Host "Running Test Engine tests..."
      
      # Create output directory
      $outputDir = "$(Build.ArtifactStagingDirectory)\TestResults"
      New-Item -ItemType Directory -Path $outputDir -Force | Out-Null
      
      # Run the tests
      pac test run `
        --test-plan-file "$(testPlan.secureFilePath)" `
        --environment-id "$(EnvironmentId)" `
        --tenant "$(TenantId)" `
        --logConsole info `
        --trx `
        --outputDirectory $outputDir
      
      if ($LASTEXITCODE -ne 0) {
          Write-Error "Test execution failed with exit code $LASTEXITCODE"
          exit $LASTEXITCODE
      }

# Publish test results
- task: PublishTestResults@2
  displayName: 'Publish Test Results'
  inputs:
    testResultsFormat: 'VSTest'
    testResultsFiles: '$(Build.ArtifactStagingDirectory)\TestResults\*.trx'
    mergeTestResults: true
    testRunTitle: 'Power Apps Test Engine Results'
  condition: always() # Ensure results are published even if tests fail

# Publish test artifacts
- task: PublishBuildArtifacts@1
  displayName: 'Publish Test Artifacts'
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)\TestResults'
    ArtifactName: 'TestArtifacts'
    publishLocation: 'Container'
  condition: always()

Componenti di riferimento

I seguenti componenti di riferimento potrebbero risultare utili durante la creazione della pipeline dei test di automazione.

Componente	Resource	Ambito
Creazione di pipeline	Crea Azure DevOps pipeline	Imposta la tua pipeline CI/CD
Controllo del codice sorgente	Dataverse Integrazione Git	Connettiti al codice sorgente della soluzione
Autenticazione	Principi di servizio e identità gestite	Connessione sicura a Dataverse
Configurazione .NET	Utilizzare l'attività dotnet v2	Installa .NET SDK se necessario
Esecuzione test	Attività di PowerShell v2	Esegui comandi pac test run
Gestione dei segreti	gruppi di variabili	Memorizza i valori di configurazione del test sicuro
File di configurazione	File protetti	Memorizza i file di configurazione del test
Accesso ai file	Scarica l'attività file sicuro v1	Accedi ai file di configurazione durante l'esecuzione della pipeline
Pubblicazione dei risultati	Pubblica i risultati del test v2	Pubblica i risultati del test (*.trx) su Azure DevOps

GitHub Runner

Ecco un esempio di un flusso di lavoro di GitHub Actions che esegue lo stesso processo di esecuzione del test:

name: Test Engine Execution

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
  workflow_dispatch:  # Allow manual triggering

jobs:
  test:
    runs-on: windows-latest
    
    env:
      TENANT_ID: ${{ secrets.TENANT_ID }}
      CLIENT_ID: ${{ secrets.CLIENT_ID }}
      CLIENT_SECRET: ${{ secrets.CLIENT_SECRET }}
      ENVIRONMENT_URL: ${{ secrets.ENVIRONMENT_URL }}
      ENVIRONMENT_ID: ${{ secrets.ENVIRONMENT_ID }}
    
    steps:
    - name: Checkout repository
      uses: actions/checkout@v3
      
    - name: Install Power Platform CLI
      run: |
        Write-Host "Installing Power Platform CLI..."
        $pacUrl = "https://aka.ms/PowerAppsCLI"
        $pacZip = "$env:TEMP\pac.zip"
        $pacDestination = "$env:TEMP\pac"
        
        # Create the destination folder if it doesn't exist
        if (-not (Test-Path $pacDestination)) {
            New-Item -ItemType Directory -Path $pacDestination -Force | Out-Null
        }
        
        # Download PAC CLI
        Invoke-WebRequest -Uri $pacUrl -OutFile $pacZip
        
        # Extract PAC CLI
        Expand-Archive -Path $pacZip -DestinationPath $pacDestination -Force
        
        # Add PAC CLI to PATH
        $env:PATH = "$pacDestination;$env:PATH"
        echo "$pacDestination" >> $env:GITHUB_PATH
        
        # Verify installation
        pac help

    - name: Install Azure CLI
      run: |
        Write-Host "Installing Azure CLI..."
        $ProgressPreference = 'SilentlyContinue'
        Invoke-WebRequest -Uri https://aka.ms/installazurecliwindows -OutFile .\AzureCLI.msi
        Start-Process msiexec.exe -Wait -ArgumentList '/I AzureCLI.msi /quiet'
        rm .\AzureCLI.msi
        
    - name: Azure CLI Authentication
      run: |
        Write-Host "Authenticating with Azure CLI..."
        az login --service-principal -u "$env:CLIENT_ID" -p "$env:CLIENT_SECRET" --tenant "$env:TENANT_ID" --allow-no-subscriptions
        
    - name: PAC CLI Authentication
      run: |
        Write-Host "Authenticating PAC CLI..."
        # Create authentication profile
        pac auth create --name TestEngineAuth --url "$env:ENVIRONMENT_URL" --applicationId "$env:CLIENT_ID" --clientSecret "$env:CLIENT_SECRET" --tenant "$env:TENANT_ID"
        
        # Select the authentication profile
        pac auth select --name TestEngineAuth
      
    - name: Run Test Engine tests
      run: |
        Write-Host "Running Test Engine tests..."
        
        # Create output directory
        $outputDir = "./TestResults"
        New-Item -ItemType Directory -Path $outputDir -Force | Out-Null
        
        # Run the tests
        pac test run `
          --test-plan-file "./TestPlan/testplan.te.yaml" `
          --environment-id "$env:ENVIRONMENT_ID" `
          --tenant "$env:TENANT_ID" `
          --logConsole info `
          --trx `
          --outputDirectory $outputDir
        
        if ($LASTEXITCODE -ne 0) {
            Write-Error "Test execution failed with exit code $LASTEXITCODE"
            exit $LASTEXITCODE
        }
    
    - name: Upload test results
      uses: actions/upload-artifact@v3
      if: always()
      with:
        name: test-results
        path: ./TestResults
        
    - name: Publish Test Results
      uses: EnricoMi/publish-unit-test-result-action@v2
      if: always()
      with:
        files: ./TestResults/**/*.trx

Articoli correlati

Scopri la sintassi YAML del Test Engine
Imposta l'autenticazione per i tuoi test
Applicazioni canvas di prova, applicazioni basate su modelli o Dataverse estensioni
Comprendere Power Platform ALM