ALM dans Power Platform avec Test Engine (version préliminaire)

Nonte

Les fonctionnalités en version préliminaire ne sont pas destinées à une utilisation en production et peuvent être restreintes. Ces fonctionnalités sont disponibles avant une version officielle afin que les clients puissent obtenir un accès anticipé et fournir des commentaires.

L’Application Lifecycle Management (ALM) est une approche globale de la gestion du cycle de vie des applications, de la conception initiale au développement, en passant par les tests, le déploiement et la maintenance continue. Dans le contexte de Power Platform, intégrer des tests automatisés à Test Engine dans votre processus ALM garantit que les applications sont testées de manière approfondie à chaque phase du développement, entraînant des versions de meilleure qualité.

Comprendre l’automatisation des tests dans ALM

L’automatisation des tests joue un rôle essentiel dans le processus ALM en :

• Assurer la qualité : vérifier que les applications fonctionnent comme prévu avant le déploiement
• Réduire les risques : détecter de manière précoce des problèmes avant qu’ils n’atteignent les environnements de production
• Activer l’intégration continue : prendre en charge des tests automatisés de vérification de build
• Faciliter les déploiements contrôlés : ajouter des portails qualité aux pipelines de mise en production

Avec Power Apps Test Engine, intégrez des tests automatisés dans vos flux de travail Power Platform ALM existants, quels que soient les outils CI/CD que vous utilisez.

Tester le cycle de vie de l’automatisation

Test Engine prend en charge un cycle de vie de test complet qui s’intègre à vos processus ALM :

1. Développement  : créer et exécuter des tests localement pendant le développement de l’application
2. Validation de build : exécuter des tests dans le cadre de la vérification automatisée du build
3. Portails de mise en production : utiliser les résultats des tests comme portails qualité pour les déploiements contrôlés
4. Vérification de la production : valider les fonctionnalités critiques dans les environnements de production

Premiers pas avec l’automatisation des tests dans ALM

Pour commencer à incorporer Test Engine dans vos processus ALM :

1. Créer votre plan de test : concevoir des plans de test YAML pour vos solutions Power Platform
2. Exécuter des tests localement : vérifier que les tests fonctionnent dans votre environnement de développement
3. Configurer l’authentification : configurer l’authentification appropriée pour vos environnements d’exécution et de pipeline locaux
4. Intégrer votre pipeline : connecter Test Engine à votre pipeline ALM existant
5. Mettre en place les portails qualité : utiliser les résultats des tests pour contrôler la promotion des solutions

Astuce

Commencez par les parcours utilisateur critiques et étendez progressivement votre couverture de tests automatisés à mesure que vous vous familiarisez avec Test Engine.

Version du code source de Test Engine (facultatif)

Si vous utilisez la version du code source de Test Engine, vous avez également besoin des éléments suivants :

• SDK .NET 8.0 : si vous envisagez de générer Test Engine à partir du source
• Git : pour extraire les modifications du référentiel Power Apps Test Engine
• Complétez les Étapes de configuration du code source pour exécuter des tests à l’aide de la version compilée locale de Test Engine

Options d’intégration

Test Engine s’intègre de manière transparente à divers outils et processus ALM

Exécution locale

Vous pouvez utiliser un éditeur local comme Visual Studio Code pour modifier les fichiers YAML afin de créer les tests Test Engine. Pour exécuter les tests localement :

1. Assurez-vous que Microsoft Power Platform CLI est installée
2. Si vous utilisez l’intégration du contrôle de code source, clonez votre projet sur votre ordinateur local
3. Utilisez la commande pac test run pour exécuter votre test
4. Passez en revue les résultats de réussite/échec du test

Azure CLI est essentiel pour obtenir des jetons d’accès pour se connecter à Dataverse. Localement, vous pouvez utiliser :

az login --allow-no-subscriptions

Pipelines Power Platform

Vous pouvez facilement intégrer Test Engine aux pipelines intégrés de Power Platform pour une expérience intégrée native :

• Pipelines de solution : ajoutez des tests automatisés à vos pipelines de solution pour garantir la qualité à chaque phase
• Stratégie d’environnement : tester dans les environnements de développement et de test avant de passer en production
• Modèles de pipeline : utiliser des modèles de pipeline pour standardiser les tests au sein de votre organisation

Vous pouvez déclencher l’exécution de tests automatisés lors de l’utilisation d’un hôte de pipelines personnalisé :

1. Créer un flux de cloud Power Automate qui se déclenche à partir d’événements de pipeline
2. Connectez-vous à votre système CI/CD pour exécuter les tests
3. Traiter les résultats des tests et mettre à jour l’état du pipeline

Le diagramme suivant montre un exemple de ce schéma d’intégration :

Ce flux utilise :

• Déclencheurs Dataverse pour démarrer un pipeline lorsque les conditions sont remplies
• Conditions de déclenchement pour déterminer quelle phase de déploiement s’applique
• Connecteur Azure DevOps pour démarrer une build avec des paramètres
• Actions d’approbation pour gérer le processus d’approbation
• Actions Dataverse pour mettre à jour le pipeline en fonction des résultats

Intégration CI/CD personnalisée avec Power Automate

Pour les organisations disposant d’outils CI/CD existants, Test Engine s’intègre aux pipelines personnalisés à l’aide Power Automate avec la fonctionnalité Hôte personnalisé Power Platform. Avec l’approche d’hôte personnalisé, vous pouvez :

• Définir un hôte de pipeline personnalisé qui exécute vos tests automatisés
• Créer des flux de cloud Power Automate qui se déclenchent automatiquement à partir d’événements de déploiement
• Exécuter des commandes pac test run directement à partir de flux de cloud pour exécuter des tests stockés dans le contrôle de code source
• Se connecter à votre système CI/CD préféré (Azure DevOps, GitHub Actions, etc.)
• Mettre en œuvre des workflows d’approbation en fonction des résultats des tests
• Mettre à jour le statut du déploiement en fonction des résultats des tests

Cette intégration vous permet de maintenir vos investissements CI/CD existants tout en ajoutant les fonctionnalités de Test Engine à votre processus ALM. L’hôte personnalisé agit comme un pont entre les fonctionnalités ALM natives de Power Platform et votre infrastructure de test externe.

Pipeline DevOps

Vous pouvez étendre votre pipeline Power Platform à l’aide d’un hôte personnalisé ou intégrer directement la commande pac test run pour exécuter directement vos scripts de build.

Voici un exemple de fichier YAML de pipeline Azure DevOps qui montre comment configurer et exécuter des tests Power Apps Test Engine :

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

Composants de référence

Les composants de référence suivants peuvent vous être utiles lors de la création de votre pipeline de tests d’automatisation.

Composant	Resource	Finalité
Création de pipeline	Créer un pipeline Azure DevOps	Configurer votre pipeline CI/CD
Contrôle de code source	Intégration de Git Dataverse	Se connecter au code source de la solution
Authentification	Principaux de services et identités gérées	Connexion sécurisée à Dataverse
Configuration de .NET	Utiliser la tâche dotnet v2	Installez le Kit de développement logiciel (SDK) .NET si nécessaire
Exécution du test	Tâche PowerShell v2	Exécuter les commandes pac test run
Gestion des clés secrètes	Groupes de variables	Stocker les valeurs de configuration de test sécurisées
Fichiers de configuration	Fichiers sécurisés	Stocker les fichiers de configuration de test
Accès aux fichiers	Télécharger la tâche de fichier sécurisé v1	Accéder aux fichiers de configuration pendant l’exécution du pipeline
Publication des résultats	Publier la tâche des résultats du test v2	Publier les résultats de test (*.trx) vers Azure DevOps

GitHub Runner

Voici un exemple de workflow GitHub Actions qui effectue le même processus d’exécution de 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

Articles associés

En savoir plus sur la syntaxe YAML de Test Engine
Configurer l’authentification pour vos tests
Tester les applications canevas, les applications pilotées par modèle ou les extensions Dataverse
Comprendre Power Platform ALM