ALM a Power Platformban a Test Engine-nel (elavult)

Megjegyzés:

A tesztmotor elavult, és egy későbbi kiadásban el lesz távolítva. Power Platform Playwright-minták használata a Power Platform és Dynamics 365 szolgáltatások automatizálási képességeinek teszteléséhez.

Az alkalmazáséletciklus-menedzsment (ALM) egy átfogó megközelítés az alkalmazások életciklusának kezelésére a kezdeti koncepciótól a fejlesztésig, a tesztelésig, a telepítésig és a folyamatos karbantartásig. A Power Platform Test Engine automatizált tesztelésének az ALM-folyamatba való beépítése biztosítja, hogy az alkalmazásokat a fejlesztés minden szakaszában alaposan teszteljék, ami jobb minőségű kiadásokat eredményez.

A tesztautomatizálás megértése az ALM-ben

A tesztautomatizálás kritikus szerepet játszik az ALM-folyamatban a következőképpen:

• Minőség biztosítása – Az alkalmazások elvárásoknak megfelelő működésének ellenőrzése a telepítés előtt
• A kockázat csökkentése – A problémák korai felismerése, mielőtt azok elérnék az éles környezetet
• Folyamatos integráció lehetővé tétele – Automatizált build-ellenőrzési tesztelés támogatása
• Ellenőrzött üzembe helyezések megkönnyítése – Minőségi kapuk hozzáadása a kiadási folyamatokhoz

A Power Apps tesztmotorral integrálhatja az automatizált tesztelést a meglévő Power Platform ALM-munkafolyamatokba, függetlenül attól, hogy melyik CI-/CD-eszközt használja.

Tesztautomatizálási életciklus

A Test Engine támogatja a teljes tesztelési életciklust, amely integrálható az ALM-folyamatokkal:

1. Fejlesztés – Tesztek helyi létrehozása és futtatása az alkalmazásfejlesztés során
2. Buildellenőrzés – Tesztek végrehajtása az automatizált buildellenőrzés részeként
3. Kiadási kapuk – Teszteredmények használata minőségi kapuként a szabályozott telepítésekhez
4. Termelési ellenőrzés – Kritikus funkciók ellenőrzése éles környezetben

Első lépések a tesztautomatizálásban az ALM-mel

A Test Engine ALM-folyamatokba való beépítésének megkezdéséhez:

1. Készítse el teszttervét – Tervezzen YAML-tesztterveket a Power Platform megoldásaihoz
2. Tesztek helyi futtatása – A tesztek fejlesztési környezetben való működésének ellenőrzése
3. Hitelesítés beállítása – Konfigurálja a megfelelő hitelesítést a helyi végrehajtási és folyamatkörnyezetekhez
4. Integráció a folyamattal – Csatlakoztassa a tesztmotort a meglévő ALM-folyamathoz
5. Minőségi kapuk megvalósítása – Használja a teszteredményeket a megoldások előléptetésének ellenőrzéséhez

Tip

Kezdje a kritikus felhasználói utakkal, és fokozatosan bővítse az automatizált tesztelési lefedettséget, ahogy jobban megismeri a Test Engine-t.

A Test Engine forráskódos verziója (opcionális)

Ha a Test Engine forráskódos verzióját használja, a következőkre is szüksége lesz:

• .NET 8.0 SDK – Ha a tesztmotort forrásból tervezi létrehozni
• Git – Módosítások lekérése Power Apps Tesztmotor-adattárból
• Hajtsa végre a forráskód telepítési lépéseit a tesztek futtatásához a Test Engine helyi lefordított verziójával

Integrációs lehetőségek

A Test Engine zökkenőmentesen integrálható a különböző ALM-eszközökkel és -folyamatokkal

Helyi végrehajtás

A Test Engine tesztek megírásához szerkesztheti a YAML fájlokat egy helyi szerkesztővel, például Visual Studio Code-dal. A tesztek helyi futtatása:

1. Győződjön meg arról, hogy telepítve van Microsoft Power Platform parancssori felület
2. Ha verziókövetési integrációt használ, klónozza a projektet a helyi gépre
3. A teszt végrehajtásához használja a pac-tesztfuttatást
4. Tekintse át a teszt sikeres / sikertelen eredményeit

A Azure CLI elengedhetetlen a Dataverse-hez való csatlakozáshoz szükséges hozzáférési jogkivonatok beszerzéséhez. Helyben a következőt használhatja:

az login --allow-no-subscriptions

A Power Platform folyamatai

A Test Engine és a Power Platform könnyen integrálható a beépített folyamatokkal a natív integrált élmény érdekében:

• Megoldási folyamatok – Adjon hozzá automatizált tesztelést a megoldási folyamatokhoz , hogy minden szakaszban biztosítsa a minőséget
• Környezetvédelmi stratégia - Tesztelés fejlesztési és tesztelési környezetben az éles környezetbe való előléptetés előtt
• Folyamatsablonok - a Folyamatsablonok használatával szabványosíthatja a tesztelést a szervezeten belül

Egyéni folyamatgazda használata esetén automatizált tesztek végrehajtását indíthatja el:

1. Folyamatesemények alapján aktiválható Power Automate felhőfolyamat létrehozása
2. Csatlakozzon a CI/CD rendszerhez a tesztek futtatásához
3. Teszteredmények feldolgozása és a folyamat állapotának frissítése

Az alábbi ábra egy példát mutat be erre az integrációs mintára:

A folyamat a következőket használja:

• Dataverse eseményindítók a folyamat elindításához, ha a feltételek teljesülnek
• Aktiválási feltételek az alkalmazandó üzembe helyezési szakasz meghatározásához
• Azure DevOps Csatlakozóval egy buildet indítani paraméterekkel
• Jóváhagyási műveletek a jóváhagyási folyamat kezeléséhez
• Dataverse műveletek a folyamat eredmények alapján történő frissítéséhez

Egyéni CI/CD-integráció a Power Automate rendszerrel

A meglévő CI/CD-eszközökkel rendelkező szervezetek esetében a Test Engine a Power Automate-en keresztül Power Platform egyéni gazda funkcióval integrálható az egyéni folyamatokkal. Az Egyéni gazda megközelítéssel a következőket teheti:

• Egy Egyéni folyamatgazda definiálása , amely végrehajtja az automatizált teszteket
• Power Automate felhőfolyamatok létrehozása, amelyek automatikusan aktiválódnak az üzembe helyezési eseményekből
• pac test run parancsok végrehajtása közvetlenül a felhőfolyamatokból a forrásvezérlőben tárolt tesztek futtatásához
• Csatlakozás az előnyben részesített CI/CD-rendszerhez (Azure DevOps, GitHub Actions stb.)
• Jóváhagyási munkafolyamatok megvalósítása teszteredmények alapján
• Üzembe helyezési állapot frissítése teszteredmények alapján

Ez az integráció lehetővé teszi a meglévő CI/CD-befektetések karbantartását, miközben hozzáadja a Test Engine képességeit az ALM-folyamathoz. Az egyéni gazda hídként működik a Power Platform natív ALM-funkciók és a külső tesztelési infrastruktúra között.

DevOps folyamat

A Power Platform-folyamatot kiterjesztheti egyéni gazda használatával, vagy közvetlenül integrálhatja a pac test run parancsot a buildszkriptjei végrehajtásához.

Íme egy példa egy Azure DevOps folyamat YAML-fájljára, amely bemutatja, hogyan állíthat be és futtathat Power Apps tesztmotor-teszteket:

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

Referenciaalkatrészek

Az alábbi referencia-összetevők hasznosak lehetnek az automatizálási tesztelési folyamat felépítésekor.

Komponens	erőforrás	Alkalmazás célja
Folyamat létrehozása	Azure DevOps-folyamat létrehozása	A CI/CD-folyamat beállítása
Forrásvezérlő	Dataverse Git-integráció	Csatlakozás a megoldás forráskódjához
Authentication	Szolgáltatásnevek és felügyelt identitások	Biztonságos kapcsolat a Dataverse felé
.NET beállítás	A dotnet v2 feladat használata	Szükség esetén telepítse .NET SDK-t
Tesztvégrehajtás	PowerShell v2-feladat	pac test run parancsok végrehajtása
Titkos kódok kezelése	Változócsoportok	Biztonságos tesztkonfigurációs értékek tárolása
Konfigurációs fájlok	Fájlok biztonságossá tétele	Tesztkonfigurációs fájlok tárolása
Fájlhozzáférés	Biztonságos fájl v1 feladat letöltése	Konfigurációs fájlok elérése a folyamatfuttatása során
Eredmények közzététele	Teszteredmények közzététele v2 feladat	Teszteredmények közzététele (*.trx) a Azure DevOps

GitHub Runner

Íme egy példa egy GitHub Actions munkafolyamatra, amely ugyanazt a tesztvégrehajtási folyamatot hajtja végre:

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

Kapcsolódó cikkek

Tudnivalók a Test Engine YAML-szintaxisáról
Hitelesítés beállítása a tesztekhez
Vászonalapú alkalmazások, modellvezérelt alkalmazások vagy Dataverse bővítmények tesztelése
A Power Platform ALM megértése