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

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

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.

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.

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