ALM in Power Platform med testmotor (förhandsversion)

Obs

Förhandsversionsfunktioner ska inte användas i produktion och funktionerna kan vara begränsade. funktionerna är tillgängliga före den officiella publiceringen så att kunderna kan få tillgång tidigare och ge oss feedback.

Application Lifecycle Management (ALM) är ett omfattande tillvägagångssätt för att hantera livscykeln för applikationer från det första konceptet genom utveckling, testning, distribution och löpande underhåll. I samband Power Platform med att du införlivar automatiserad testning med testmotor i din ALM-process säkerställer du att applikationerna testas noggrant i varje utvecklingssteg, vilket resulterar i utgåvor av högre kvalitet.

Förstå testautomatisering i ALM

Testautomatisering spelar en avgörande roll i ALM-processen genom att:

• Säkerställa kvalitet – Verifiera att programmen fungerar som förväntat före distributionen
• Minska risken – Fånga upp problem tidigt innan de når produktionsmiljöer
• Möjliggöra kontinuerlig integrering – Stöd för automatiserad testning av byggverifiering
• Underlätta kontrollerade distributioner – Lägga till kvalitetsgrindar för att släppa pipelines

Med Power Apps Test Engine kan du integrera automatiserad testning i dina befintliga Power Platform ALM-arbetsflöden, oavsett vilka CI/CD-verktyg du använder.

Livscykel för testautomatisering

Testmotorn stöder en komplett testlivscykel som integreras med dina ALM-processer:

1. Utveckling – Skapa och köra tester lokalt under apputvecklingen
2. Byggvalidering – Kör tester som en del av automatiserad byggverifiering
3. Releasegrindar – Använd testresultat som kvalitetsgrindar för kontrollerade distributioner
4. Produktionsverifiering – Validera kritiska funktioner i produktionsmiljöer

Komma igång med testautomatisering i ALM

Så här kommer du igång med att integrera Test Engine i dina ALM-processer:

1. Skapa din testplan – Utforma YAML-testplaner för dina Power Platform lösningar
2. Köra tester lokalt – Kontrollera att testerna fungerar i utvecklingsmiljön
3. Konfigurera autentisering – Konfigurera lämplig autentisering för dina lokala körnings- och pipelinemiljöer
4. Integrera med din pipeline - Anslut testmotorn till din befintliga ALM-pipeline
5. Implementera kvalitetsgrindar - Använd testresultat för att kontrollera marknadsföringen av lösningar

Tips!

Börja med viktiga användarresor och utöka gradvis din automatiserade testtäckning när du blir mer bekant med Test Engine.

Källkodsversion av testmotorn (valfritt)

Om du använder källkodsversionen av Test Engine behöver du också:

• .NET 8.0 SDK – Om du planerar att skapa testmotorn från källan
• Git - För att hämta ändringar från Power Apps testmotorns lagringsplats
• Slutför installationsstegen för källkoden för att köra tester med den lokala kompilerade versionen av testmotorn

Integreringsalternativ

Testmotorn integreras sömlöst med olika ALM-verktyg och processer

Lokal körning

Du kan använda en lokal redigerare som Visual Studio Code för att redigera YAML-filerna för att skapa testmotortesterna. Så här kör du testerna lokalt:

1. Kontrollera att du har Microsoft Power Platform CLI installerat
2. Om du använder integrering av källkontroll klonar du projektet till den lokala datorn
3. Använd pac-testkörningen för att köra testet
4. Granska resultatet av testet, som är godkänt/underkänt

Azure CLI är viktigt för att hämta åtkomsttoken att ansluta till Dataverse. Lokalt kan du använda:

az login --allow-no-subscriptions

Power Platform Rörledningar

Du kan enkelt integrera testmotorn med Power Platform inbyggda pipelines för en inbyggd integrerad upplevelse:

• Lösningspipelines – Lägg till automatiserad testning i dina lösningspipelines för att säkerställa kvalitet i varje steg
• Miljöstrategi - Testa i utvecklings- och testmiljöer innan du befordrar till produktion
• Pipelinemallar – Använd pipelinemallar för att standardisera testning i hela organisationen

Du kan utlösa körning av automatiserade tester när du använder en anpassad pipelinevärd:

1. Skapa ett Power Automate molnflöde som utlöses baserat på pipelinehändelser
2. Anslut till ditt CI/CD-system för att köra testerna
3. Bearbeta testresultat och uppdatera pipelinestatusen

Följande diagram visar ett exempel på det här integreringsmönstret:

I det här flödet används:

• Dataverse Utlösare för att starta en pipeline när villkoren uppfylls
• Utlösande villkor för att avgöra vilket distributionssteg som gäller
• Azure DevOps Anslutningsapp för att starta en version med parametrar
• Godkännandeåtgärder för att hantera godkännandeprocessen
• Dataverse Åtgärder för att uppdatera pipelinen baserat på resultat

Anpassad CI/CD-integrering med Power Automate

För organisationer med befintliga CI/CD-verktyg integreras Test Engine med anpassade pipelines med hjälp av Power Automate Power Platform funktionen Anpassad värd . Med metoden Anpassad värd kan du:

• Definiera en anpassad pipelinevärd som kör dina automatiserade tester
• Skapa Power Automate molnflöden som utlöses automatiskt från distributionshändelser
• Kör pac test run kommandon direkt från molnflöden för att köra tester som lagras i källkontrollen
• Anslut till önskat CI/CD-system (Azure DevOps, GitHub Actions osv.)
• Implementera arbetsflöden för godkännande baserat på testresultat
• Uppdatera distributionsstatus baserat på testresultaten

Med den här integreringen kan du underhålla dina befintliga CI/CD-investeringar samtidigt som du lägger till testmotorns funktioner i ALM-processen. Den anpassade värden fungerar som en brygga mellan Power Platform de inbyggda ALM-funktionerna och din externa testinfrastruktur.

DevOps-pipeline

Du kan utöka din Power Platform pipeline med hjälp av en anpassad värd eller direkt integrera kommandot pac test run för att köra dina byggskript.

Här är ett exempel på en Azure DevOps YAML-pipelinefil som visar hur du konfigurerar och kör Power Apps testmotortester:

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

Referens komponenter

Följande referenskomponenter kan vara användbara när du skapar din pipeline för automatiseringstest.

Komponent	Resource	Purpose
Skapa pipeline	Skapa Azure DevOps pipeline	Konfigurera din CI/CD-pipeline
Källkontroll	Dataverse Git-integrering	Ansluta till lösningens källkod
Autentisering	Tjänstens huvudnamn och hanterade identiteter	Säker anslutning till Dataverse
NET-installation	Använda dotnet v2-uppgift	Installera .NET SDK om det behövs
Testkörning	PowerShell v2-uppgift	Köra pac test run kommandon
Hantering av hemligheter	Variabla grupper	Lagra säkra testkonfigurationsvärden
Konfigurera filer	Säkra filer	Lagra testkonfigurationsfiler
Åtkomst till filer	Ladda ned säker fil v1-uppgift	Få åtkomst till konfigurationsfiler under pipelinekörning
Publicering av resultat	Publicera testresultat v2-uppgift	Publicera testresultat (*.trx) till Azure DevOps

GitHub Runner

Här är ett exempel på ett GitHub Actions arbetsflöde som utför samma testkörningsprocess:

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

Relaterade artiklar

Lär dig mer om YAML-syntax för testmotorn
Konfigurera autentisering för dina tester
Testa arbetsyteprogram, modellbaserade program eller Dataverse tillägg
Förstå Power Platform ALM