ALM in Power Platform mit Test Engine (Vorschauversion)

Notiz

Funktionen in der Vorschau sind nicht für den Produktionseinsatz gedacht und können eine eingeschränkte Funktionalität aufweisen. Diese Funktionen stehen vor der offiziellen Veröffentlichung zur Verfügung, damit Kunden frühzeitig Zugriff erhalten und Feedback geben können.

Application Lifecycle Management (ALM) ist ein umfassender Ansatz zur Verwaltung des Lebenszyklus von Anwendungen vom ersten Konzept über die Entwicklung, das Testen und Bereitstellung bis zur laufenden Wartung. Im Zusammenhang mit Power Platform stellt die Integration automatisierter Tests mit Test Engine in ihren ALM-Prozess sicher, dass Anwendungen in jeder Phase der Entwicklung gründlich getestet werden, was die Qualität der Releases steigert.

Grundlegendes zur Testautomatisierung im ALM

Die Testautomatisierung spielt im ALM-Prozess eine entscheidende Rolle, indem sie:

• Die Qualität sicherstellt: Es wird vor der Bereitstellung überprüft, ob Anwendungen wie erwartet funktionieren
• Das Risiko reduziert: Probleme werden frühzeitig erkannt, bevor sie in Produktionsumgebungen gelangen
• Die kontinuierliche Integration ermöglicht: Automatisierte Build-Überprüfungstests werden unterstützt
• Kontrollierte Bereitstellungen ermöglicht: Release-Pipelines werden Qualitätsprüfungen hinzugefügt

Mit der Power Apps Test Engine können Sie automatisierte Tests in Ihre bestehenden Power Platform ALM-Workflows integrieren, und zwar unabhängig davon, welche CI/CD-Tools Sie verwenden.

Lebenszyklus der Testautomatisierung

Test Engine unterstützt einen vollständigen Testlebenszyklus, der in Ihre ALM-Prozesse integriert ist:

1. Entwicklung: Lokales Erstellen und Ausführen von Tests während der App-Entwicklung
2. Build-Überprüfung: Ausführen von Tests als Teil der automatisierten Build-Überprüfung
3. Qualitätsprüfungen: Verwenden von Testergebnissen als Qualitätsprüfung für kontrollierte Bereitstellungen
4. Produktionsverifizierung: Validieren kritischer Funktionen in Produktionsumgebungen

Erste Schritte mit der Testautomatisierung in ALM

So beginnen Sie mit der Integration von Test Engine in Ihre ALM-Prozesse:

1. Erstellen Sie Ihren Testplan: Gestalten Sie YAML-Testpläne für Ihre Power Platform-Lösungen
2. Führen Sie Tests lokal aus: Überprüfen Sie, ob Tests in Ihrer Entwicklungsumgebung funktionieren
3. Richten Sie die Authentifizierung ein: Konfigurieren Sie die angemessene Authentifizierung für Ihre lokalen Ausführungs- und Pipelineumgebungen
4. Nehmen Sie die Integration mit Ihrer Pipeline vor: Verbinden Sie Test Engine mit Ihrer vorhandenen ALM-Pipeline
5. Implementieren Sie Qualitätsprüfungen: Verwenden Sie Testergebnisse, um die Höherstufung von Lösungen zu steuern

Tipp

Beginnen Sie mit kritischen User Journeys und erweitern Sie die Abdeckung mit automatisierten Tests, wenn Sie sich mit Test Engine vertrauter werden.

Quellcodeversion von Test Engine (optional)

Wenn Sie die Quellcodeversion von Test Engine verwenden, benötigen Sie außerdem:

• .NET 8.0 SDK, wenn Sie planen, Test Engine aus der Quelle zu erstellen
• Git, um Änderungen aus dem Power Apps Test Engine-Repository abzurufen
• Führen Sie die Einrichtungsschritte für den Quellcode aus, um Tests mit der lokal kompilierten Version von Test Engine auszuführen

Integrationsoptionen

Test Engine lässt sich nahtlos in verschiedene ALM-Tools und -Prozesse integrieren

Lokale Ausführung

Sie können einen lokalen Editor wie Visual Studio Code verwenden, um die YAML-Dateien zu bearbeiten und die Test für Test Engine zu erstellen. Um die Test lokal auszuführen:

1. Stellen Sie sicher, dass Microsoft Power Platform CLI installiert ist
2. Wenn Sie die Integration der Quellcodeverwaltung verwenden, klonen Sie Ihr Projekt auf Ihren lokalen Computer
3. Verwenden Sie den pac-Testlauf, um den Test auszuführen
4. Überprüfen Sie, ob die Tests bestanden/nicht bestanden wurden

Die Azure CLI ist unerlässlich, um Zugriffstoken für die Verbindung mit Dataverse zu erhalten. Lokal können Sie Folgendes verwenden:

az login --allow-no-subscriptions

Power Platform Pipelines

Sie können Test Engine problemlos in die integrierten Pipelines von Power Platform integrieren, um eine native integrierte Erfahrung zu erreichen:

• Lösungspipelines: Fügen Sie Ihren Lösungspipelines automatisierte Tests hinzu, um die Qualität in jeder Phase sicherzustellen
• Umgebungsstrategie: Testen Sie in Entwicklungs- und Testumgebungen vor der Höherstufung auf die Produktion
• Pipelinevorlagen: Verwenden Sie Pipelinevorlagen, um Tests in Ihrer Organisation zu standardisieren

Sie können die Ausführung automatisierter Tests auslösen, wenn Sie einen benutzerdefinierten Pipelinehost verwenden:

1. Erstellen Sie einen Power Automate-Cloud-Flow, der anhand von Pipeline-Ereignissen ausgelöst wird
2. Stellen Sie eine Verbindung zu Ihrem CI/CD-System her, um die Tests auszuführen
3. Verarbeiten Sie Testergebnisse und aktualisieren Sie den Pipeline-Status

Das folgende Diagramm zeigt ein Beispiel für dieses Integrationsmuster:

Dieser Flow verwendet:

• Dataverse-Trigger, um eine Pipeline zu starten, wenn die Bedingungen erfüllt sind
• Trigger-Bedingungen, um zu bestimmen, welche Bereitstellungsphase gilt
• Einen Azure DevOps-Connector, um einen Build mit Parametern zu starten
• Genehmigungsaktionen, um die Genehmigungsprozesse zu verwalten
• Dataverse-Aktionen, um die Pipeline basierend auf den Ergebnissen zu aktualisieren

Benutzerdefinierte CI/CD-Integration mit Power Automate

Wenn Unternehmen bereits über CI/CD-Tools verfügen, lässt sich Test Engine durch Power Automate mithilfe des Features Benutzerdefinierter Power Platform-Host in benutzerdefinierte Pipelines integrieren. Mit dem Ansatz des benutzerdefinierten Hosts können Sie:

• Einen benutzerdefinierten Pipelinehost festlegen, der Ihre automatisierten Tests ausführt
• Power Automate-Cloud-Flows erstellen, die automatisch aus Bereitstellungsereignissen ausgelöst werden
• pac test run-Befehle direkt aus Cloud-Flows ausführen, um Tests auszuführen, die in der Quellcodeverwaltung gespeichert sind
• Eine Verbindung zu Ihrem bevorzugten CI/CD-System herstellen (Azure DevOps, GitHub Actions usw.)
• Genehmigungsworkflows auf der Grundlage von Testergebnissen implementieren
• Den Bereitstellungsstatus basierend auf den Testergebnissen aktualisieren

Mit dieser Integration können Sie Ihre vorhandenen CI/CD-Investitionen beibehalten und gleichzeitig die Funktionen von Test Engine zu Ihrem ALM-Prozess hinzuzufügen. Der benutzerdefinierte Host fungiert als Brücke zwischen den nativen ALM-Features von Power Platform und Ihrer externen Testinfrastruktur.

DevOps-Pipeline

Sie können Ihre Power Platform-Pipeline mit einem benutzerdefinierten Host erweitern oder den Befehl pac test run direkt integrieren, um Ihre Build-Skripte auszuführen.

Hier ist ein Beispiel für eine Azure DevOps-Pipeline-YAML-Datei, die veranschaulicht, wie Sie Tests der Power Apps Test Engine einrichten und ausführen:

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

Referenzkomponenten

Die folgenden Referenzkomponenten können beim Erstellen Ihrer Automatisierungstestpipeline hilfreich sein.

Komponente	Ressource	Zweck
Pipeline-Erstellung	Azure DevOps-Pipeline erstellen	Ihre CI/CD-Pipeline einrichten
Quellcodeverwaltung	Dataverse-Git-Integration	Mit Lösungsquellcode verbinden
Authentifizierung	Dienstprinzipale und verwaltete Identitäten	Verbindungen zu Dataverse sichern
.NET-Einrichtung	DotNet-v2-Aufgabe verwenden	Bei Bedarf das .NET SDK installieren
Testausführung	PowerShell-v2-Aufgabe	pac test run-Befehle ausführen
Geheimnisverwaltung	Variablengruppen	Sichere Testkonfigurationswerte speichern
Konfigurationsdateien	Dateien sichern	Testkonfigurationsdateien speichern
Dateizugriff	Aufgabe „Sichere Datei v1 herunterladen“	Während der Pipelineausführung auf Konfigurationsdateien zugreifen
Ergebnisse veröffentlichen	Aufgabe „Testergebnisse v2 veröffentlichen“	Testergebnisse (*.trx) an Azure DevOps veröffentlichen

GitHub Runner

Hier ist ein Beispiel für einen GitHub Actions-Workflow, der denselben Testausführungsprozess ausführt:

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

Ähnliche Artikel

Weitere Informationen über die YAML-Syntax von Test Engine
Authentifizierung für Ihre Tests einrichten
Canvas-Anwendungen, modellgesteuerte Anwendungen oder Dataverse-Erweiterungen testen
Grundlegendes zu Power Platform ALM